frontend/apps/wr/app/store/map/ruseMap/index.tsx

import { fetchType, getFetch, postFectch } from "@/components/lib/api";
import type { CommonTableProps } from "../../common/type/header";
import type { WaterReuseFacility } from "../../ruseFcltMng/fcltSttn/pbnstSttn/type";
import {
  pbnstSttNodeListExport,
  pbnSttHeadListExport,
} from "../../ruseFcltMng/fcltSttn/pbnstSttn/headList";
import type { ReturnType } from "@common/business_components/ui";
import { hasuListFetch } from "../../ruseFcltMng/fcltSttn/pbnstSttn";
import type { customPbnst } from "../../ruseFcltMng/fcltReg/pbnstReg/type";
import { excelPbnstSttnParsing } from "../../ruseFcltMng/fcltSttn/pbnstSttn/excel";

export const ruseMapSize = 15;
export type ruseMapState = {
  ruseMap: {
    ruseMapRes: WaterReuseFacility[];
    ruseMapCount: number;
    isInit: boolean;
    fclts: string[];
    ruseExcelList: [];
    ruseDetailList: customPbnst[];
    ruseMapHeadList: CommonTableProps[];
    ruseMapNodeList: CommonTableProps[];
  };
};

type ruseMapActions = {
  getMapFlcts: () => void;
  ruseMapInit: (
    page: number,
    total: number,
    reurnValue: ReturnType,
    year: string,
    fclts: string[]
  ) => void;
  ruseMapSearch: (
    isExcel: boolean,
    page: number,
    total: number,
    reurnValue: ReturnType,
    year: string,
    fclts: string[],
    fcltNm: string
  ) => void;
  getRuseMaplList: (bscFctCd: string) => void;
  getRuseMaplListReturn: (bscFctCd: string) => Promise<customPbnst | undefined>;
};

export type ruseMapType = ruseMapState & ruseMapActions;

export const ruseMapStateExport: ruseMapState = {
  ruseMap: {
    isInit: false,
    ruseMapRes: [],
    ruseDetailList: [],
    fclts: [],
    ruseMapCount: 1,
    ruseExcelList: [],
    ruseMapHeadList: pbnSttHeadListExport,
    ruseMapNodeList: pbnstSttNodeListExport,
  },
};

export const ruseMapActionsExport: (set: any) => ruseMapActions = (
  set: any
) => {
  return {
    getMapFlcts: async () => {
      const fclts = await getFetch(fetchType.WR, "/reuseFc/pubFc");

      return set((state: ruseMapState) => ({
        ruseMap: {
          ...state.ruseMap,
          fclts: fclts,
        },
      }));
    },
    ruseMapInit: async (
      page: number,
      total: number,
      reurnValue: ReturnType,
      year: string,
      fclts: string[]
    ) => {
      try {
        const ruseMapRes = await hasuListFetch(
          String(page),
          String(total),
          reurnValue,
          undefined,
          year,
          fclts
        );
        set((state: ruseMapState) => {
          return {
            ...state,
            ruseMap: {
              ...state.ruseMap,
              ruseMapRes: ruseMapRes.data,
              ruseMapCount: ruseMapRes.count,
              isInit: false,
            },
          };
        });
      } catch (e) {
        console.log(e);
      }
    },
   
    getRuseMaplList: async (bscFctCd: string) => {
      try {
        const ruseDetailList = await getFetch(
          fetchType.WR,
          `/reuseFc/pubFc/${bscFctCd}`
        );
        const year = new Date().getFullYear();
        const data = [bscFctCd];
        const rusePrfList = await postFectch(
          `/reuseFc/pubDetailList/${year}/0/1/10`,
          data,
          fetchType.WR
        );
        const dataList = ruseDetailList.map((ruse) => {
          const matchRuse = rusePrfList?.data.find(
            (prf) => prf.pbnstRuseFcltId === ruse.pbnstRuseFcltId
          );
          return {
            ...ruse,
            prfList: matchRuse.prfList,
          };
        });
        console.log("/dataList ", dataList);
        set((state: ruseMapState) => {
          return {
            ...state,
            ruseMap: {
              ...state.ruseMap,
              ruseDetailList: dataList,
            },
          };
        });
      } catch (errorHasu) {
        console.log(errorHasu);
        throw errorHasu; // 호출부에서 catch 가능하도록
      }
    },
    ruseMapSearch: async (
      isExcel: boolean,
      page: number,
      total: number,
      reurnValue: ReturnType,
      year: string,
      fclts: string[],
      fcltNm: string
    ) => {
      try {
        const ruseMapRes = await hasuListFetch(
          String(page),
          String(total),
          reurnValue,
          fcltNm,
          year,
          fclts
        );
        if (isExcel) {
          const ruseMapExcel = excelPbnstSttnParsing(ruseMapRes.data);
          set((state: ruseMapState) => {
            return {
              ...state,
              ruseMap: {
                ...state.ruseMap,
                ruseExcelList: ruseMapExcel,
              },
            };
          });
        } else {
          set((state: ruseMapState) => {
            return {
              ...state,
              ruseMap: {
                ...state.ruseMap,
                ruseMapRes: ruseMapRes.data,
                ruseMapCount: ruseMapRes.count,
                isInit: false,
              },
            };
          });
        }
      } catch (e) {
        console.log(e);
      }
    },

    getRuseMaplListReturn: async (bscFctCd: string) => {
      try {
        const ruseDetailList = await getFetch(
          fetchType.WR,
          `/reuseFc/pubFc/${bscFctCd}`
        );
        const year = new Date().getFullYear();
        const data = [bscFctCd];
        const rusePrfList = await postFectch(
          `/reuseFc/pubDetailList/${year}/0/1/10`,
          data,
          fetchType.WR
        );
        const dataList = ruseDetailList.map((ruse) => {
          const matchRuse = rusePrfList?.data.find(
            (prf) => prf.pbnstRuseFcltId === ruse.pbnstRuseFcltId
          );


          const usage = matchRuse.prfList.reduce(
            (acc, cur) => {
              acc.inUsage +=
                cur.wshwtr +
                cur.coolUswtr +
                cur.cleanUswtr +
                cur.drwtUswtr +
                cur.dltnUswtr +
                cur.ithlRswtr +
                cur.ithlEtcUswtr +
                cur.cleanToilUswtr +
                cur.resn;
              acc.outUsage +=
                cur.lndwtr +
                cur.hydUswtr +
                cur.ugwtChr +
                cur.farmUswtr +
                cur.rvrKeepUswtr +
                cur.indstUswtr;
              acc.total = acc.inUsage + acc.outUsage;
  
              return acc;
            },
            { total: 0, inUsage: 0, outUsage: 0 }
          );


          return {
            ...ruse,
            prfList: matchRuse.prfList,
            inUsage: usage?.inUsage,
            outUsage: usage?.outUsage,

          };
        });
        return dataList
      } catch (errorHasu) {
        console.log(errorHasu);
        throw errorHasu; // 호출부에서 catch 가능하도록
      }
    }
  };
};