/**====================================
 * 보편적으로 쓰는 store 공간
 ====================================**/

import { getFetch, getFetchAreaList } from "@/app/components/api";

/**
 * STORE - TYPE
 */

// selectBox
export type SelectDataType = {
  text: string;
  val: string;
}
// grid header
export type TableUpperProps = {
  id: string;
  title: string;
  upName?: string;
  upSequnce?: number;
}

// 시도 데이터
export type sidoDataType = {
  adstDstrCd: number,
  sido: string,
}

// 시군구 데이터
export type sigunDataType = {
  adstDstrCd: number,
  gugun: string
}

// 권역 데이터
export type regionDataType = {
  rvbsnCd: string,
  rvbsn: string,
}

// 단위유역 데이터
export type unitWaterShedDataType = {
  rvbsnCd: string,
  lgbsn: string,
}

// 중권역 데이터
export type middleRegionDataType = {
  rvbsnCd: string,
  mdmbsn: string,
}

// 환경청 데이터
export type envPartDataType = {
  lclgvrnmntCd: string,
  lclgvrnmntNm: string,
  adstDliStrCd: string,
  adstDstrCd: string,
}

export type envPartSelectDataType = SelectDataType & {
  adstDliStrCd: string,
}

export interface MenuItem {
  menuCd: number;
  menuKornNm: string;
  menuEngNm: string;
  parentId: number | null;
  sortSeq: number;
  iconNm?: string;
  children: MenuItem[] | null;
  levelNo: number;
  urlPath: string;
  menuLnkgTypeCd: string;
  menuLnkgSn: number;
  menuPath: string;
  qrcd: string;
  useYn: string;
  otptYn: string;
  newWndwYn: string;
  requiredUrlPath: boolean;
}

/**
 * STORE - DATA
 */

// 시도 데이터
let selectSidoData: SelectDataType[] = [
  { text: "전체", val: '0' }
];

// 시군구 데이터
let selectSigunData: SelectDataType[] = [
  { text: "전체", val: '0' }
];

// 권역 데이터
const selectRegionData: SelectDataType[] = [
  { text: "전체", val: '0' }
];

// 단위유역 데이터
const selectUnitWaterShedData: SelectDataType[] = [
];

// 환경청 데이터
let selectEnvPartData: envPartSelectDataType[] = [
  { text: "전체", val: '0', adstDliStrCd: '' }
];

// 환경청 내 시도 데이터
const selectEnvPartSidoData: SelectDataType[] = [
  { text: "전체", val: '0' }
];

// 환경청 내 시군구 데이터
const selectEnvPartSigunData: SelectDataType[] = [
  { text: "전체", val: '0' }
];

// 구분 데이터
// const selectPartData:SelectDataType[] = [
//   { text: "행정별", val: '0' },
//   { text: "유역별", val: '01' },
//   { text: "환경청별", val: '02' },
// ];

// 상향 하향 데이터
const selectUpdownData: SelectDataType[] = [
  { text: "전체", val: '0' },
  { text: "500미만", val: '400' },
  { text: "500이상", val: '500' },
];

// 운영 상태 데이터
const selectOperationData: SelectDataType[] = [
  { text: "전체", val: '0' },
  { text: "가동중", val: '1' },
  { text: "재가동", val: '2' },
  { text: "가동중지", val: '3' },
  { text: "시설폐쇄", val: '4' },
];

// 시설 구분 데이터
const selectFacilityPartData: SelectDataType[] = [
  { text: "전체", val: '0' },
  { text: "공공하수처리시설", val: 'SW' },
  { text: "오수처리장", val: 'SS' },
  { text: "개인하수처리시설", val: 'PB' },
  { text: "분뇨처리장", val: 'NS' },
  { text: "폐수처리장", val: 'LW' },
  { text: "침출수처리장", val: 'LC' },
  { text: "기타기초시설", val: 'ET' },
];

// 년도 데이터
const getYearData = () => {
  const today = new Date();
  const year = today.getFullYear();
  const month = today.getMonth() + 1;

  // 상반기(6월까지)는 2년 전, 하반기는 1년 전부터 시작
  const startYear = month <= 6 ? (year - 2) : (year - 1);

  const year1 = startYear;
  const year2 = startYear - 1;
  const year3 = startYear - 2;
  const year4 = startYear - 3;
  const year5 = startYear - 4;
  return [
    { text: year1 + "년", val: year1.toString() },
    { text: year2 + "년", val: year2.toString() },
    { text: year3 + "년", val: year3.toString() },
    { text: year4 + "년", val: year4.toString() },
    { text: year5 + "년", val: year5.toString() },
  ]
}

const selectSearchYear: SelectDataType[] = getYearData();

// 유량 기간 구분
const selectFlowTerm: SelectDataType[] = [
  { text: "연간", val: '0' },
  { text: "하절기", val: '01' },
  { text: "동절기", val: '02' },
  { text: "청천시", val: '03' },
  { text: "강우시", val: '04' },
];

// 유량 기간 구분
const selectFlowPanel: SelectDataType[] = [
  { text: "전체", val: '0' },
  { text: "3~10mm미만", val: '2' },
  { text: "10~20mm미만", val: '3' },
  { text: "20~30mm미만", val: '4' },
  { text: "30~40mm미만", val: '5' },
  { text: "40~50mm미만", val: '6' },
  { text: "50~60mm미만", val: '7' },
  { text: "60mm이상", val: '8' },
];

// 중권역 데이터
const selectMiddleRegionData: SelectDataType[] = [
  { text: "전체", val: '0' }
];

// 오수전환율
export const OSU_PERCENT = 0.9;

/**
 * 반올림 함수 
 * @param value : 대상 숫자
 * @param precision : 반올림할 자릿수
 * @returns 
 */
export const roundUp = (value: number, precision: number = 1): number => {
  return Math.round(value * (10 ** precision)) / (10 ** precision);
}

/**
 * 수질 데이터 포맷 변경 함수
 * @param value : 수질 데이터
 * @param day : 일수
 * @param digit : 소수점 자리수
 */
export const qltyDataSetting = (value: number, day: number, digit: number) => {
  const toZero = digit === 1 ? '0.0' : digit === 2 ? '0.00' : '0.000';
  return value > 0 ? roundUp((value / day), digit).toFixed(digit) : toZero;
};

export const COD_YEAR = 2021;

/**
 * STORE - API
 */

// 처리시설 계획정보 호출 (알에스원)
export const planInfoUrl = '/dc-service/api/v1/nowDmgMtncGnsvy';

export const fetchPlanInfo = async (targetYear: string | undefined, ctpvNm: string | undefined, sggNm: string | undefined, fcltyCd: string | undefined) => {
  try {
    const baseUrl = planInfoUrl;
    const queryParams = new URLSearchParams();
    if (ctpvNm && ctpvNm !== '전체') queryParams.append('ctpvNm', ctpvNm);
    if (sggNm && sggNm !== '전체') queryParams.append('sggNm', sggNm);
    if (targetYear) queryParams.append('targetYear', targetYear);
    if (fcltyCd) queryParams.append('swtrmtFcltCd', fcltyCd);
    const queryString = queryParams.toString();
    const url = queryString ? `${baseUrl}?${queryString}` : baseUrl;
    const res = await getFetchAreaList(url);
    return res;
  } catch (error) {
    console.error('처리시설 계획정보를 가져오는데 실패했습니다:', error);
    return [];
  }
}

// 시도 API 호출 함수 추가
const fetchSidoData = async (): Promise<SelectDataType[]> => {
  try {
    const res = await getFetch('fo', '/addr/city');
    const data = res.data;
    selectSidoData = [
      { text: "전체", val: '0' },
      ...data.map((item: sidoDataType) => ({
        text: item.sido || '',
        val: String(item.adstDstrCd) || ''
      }))
    ];
    return selectSidoData;
  } catch (error) {
    console.error('시도 데이터를 가져오는데 실패했습니다:', error);
    return selectSidoData;
  }
};

// 시군구 API 호출 함수 추가
const fetchSigunData = async (): Promise<SelectDataType[]> => {
  try {
    const res = await getFetch('fo', '/addr/sgg');
    const data = res.data;
    selectSigunData = [
      { text: "전체", val: '0' },
      ...data
        .map((item: sigunDataType) => ({
          text: item.gugun || '',
          val: String(item.adstDstrCd) || ''
        }))
    ];
    return selectSigunData;
  } catch (error) {
    console.error('시군구 데이터를 가져오는데 실패했습니다:', error);
    return selectSigunData;
  }
};

// 권역 API 호출 함수 추가
const fetchRegionData = async (): Promise<SelectDataType[]> => {
  try {
    const res = await getFetch('fo', '/addr/sarea');
    const data = res.data;
    return [
      { text: "전체", val: '0' },
      ...data.map((item: regionDataType) => ({
        text: item.rvbsn || '',
        val: String(item.rvbsnCd) || ''
      }))
    ];
  } catch (error) {
    console.error('권역 데이터를 가져오는데 실패했습니다:', error);
    return selectRegionData;
  }
};

// 중권역 API 호출 함수 추가
const fetchMiddleRegionData = async (): Promise<SelectDataType[]> => {
  try {
    const res = await getFetch('fo', '/addr/midArea');
    const data = res.data;
    return [
      { text: "전체", val: '0' },
      ...data
        .map((item: middleRegionDataType) => ({
          text: item.mdmbsn || '',
          val: String(item.rvbsnCd) || ''
        }))
    ];
  } catch (error) {
    console.error('중권역 데이터를 가져오는데 실패했습니다:', error);
    return selectMiddleRegionData;
  }
};

// 단위유역 API 호출 함수 추가
const fetchUnitWaterShedData = async (): Promise<SelectDataType[]> => {
  try {
    const res = await getFetch('fo', '/addr/largeArea');
    const data = res.data;
    return [
      { text: "전체", val: '0' },
      ...data
        .map((item: unitWaterShedDataType) => ({
          text: item.lgbsn || '',
          val: String(item.rvbsnCd) || ''
        }))
    ];
  } catch (error) {
    console.error('단위유역 데이터를 가져오는데 실패했습니다:', error);
    return selectUnitWaterShedData;
  }
};

// 환경청 데이터
const fetchEnvPartData = async (): Promise<envPartSelectDataType[]> => {
  try {
    const res = await getFetch('fo', '/addr/govArea');
    const data = res.data;
    selectEnvPartData = [
      { text: "전체", val: '0', adstDliStrCd: '' },
      ...data
        .map((item: envPartDataType) => ({
          text: item.lclgvrnmntNm || '',
          val: String(item.lclgvrnmntCd) || '',
          adstDliStrCd: item.adstDliStrCd || ''
        }))
    ];
    return selectEnvPartData;
  } catch (error) {
    console.error('환경청 데이터를 가져오는데 실패했습니다:', error);
    return selectEnvPartData;
  }
};

/**====================================
 * Store - expaort
 ====================================*/
export type CommonAction = {
  getMenuAuth: (menuCd: number) => Promise<void>;
  initializeCommonData: () => Promise<void>;
}

export type CommonType = {
  Common: {
    isInit: boolean;
    selectSidoData: SelectDataType[];
    selectSigunData: SelectDataType[];
    selectUpdownData: SelectDataType[];
    selectOperationData: SelectDataType[];
    selectFacilityPartData: SelectDataType[];
    selectSearchYear: SelectDataType[];
    selectUnitWaterShedData: SelectDataType[];
    selectRegionData: SelectDataType[];
    selectMiddleRegionData: SelectDataType[];
    selectEnvPartSidoData: SelectDataType[];
    selectEnvPartSigunData: SelectDataType[];
    selectFlowTerm: SelectDataType[];
    selectFlowPanel: SelectDataType[];
    selectEnvPartData: envPartSelectDataType[];
    btnClass: string;
    COD_YEAR: number;
  };

  auth: {
    mngAuthrtYn: string;
    inqAuthrtYn: string;
    regAuthrtYn: string;
    mdfcnAuthrtYn: string;
    delAuthrtYn: string;
  };
};

export const commonState: CommonType = {
  Common: {
    isInit: false,
    selectSidoData: selectSidoData,
    selectSigunData: selectSigunData,
    selectUpdownData: selectUpdownData,
    selectOperationData: selectOperationData,
    selectFacilityPartData: selectFacilityPartData,
    selectSearchYear: selectSearchYear,
    selectRegionData: selectRegionData,
    selectUnitWaterShedData: selectUnitWaterShedData,
    selectMiddleRegionData: selectMiddleRegionData,
    selectEnvPartSidoData: selectEnvPartSidoData,
    selectEnvPartSigunData: selectEnvPartSigunData,
    selectFlowTerm: selectFlowTerm,
    selectFlowPanel: selectFlowPanel,
    selectEnvPartData: selectEnvPartData,
    btnClass: "p-4 m-2 !mr-10 text-white rounded-sm text-lg font-medium",
    COD_YEAR: COD_YEAR,
  },

  auth: {
    mngAuthrtYn: "N",
    inqAuthrtYn: "N",
    regAuthrtYn: "N",
    mdfcnAuthrtYn: "N",
    delAuthrtYn: "N",
  },
};

export const CommonReducer = (
  set: (fn: (state: CommonType) => CommonType) => void
): CommonAction => {
  return {
    // 메뉴 권한 확인
    getMenuAuth: async (menuCd: number) => {
      const response = await getFetch(
        "local",
        `/cms-service/api/v1/menu-authrts/pageinfo/${menuCd}`
      );
      set((state: CommonType) => {
        return {
          ...state,
          auth: {
            mngAuthrtYn: response[0].mngAuthrtYn,
            inqAuthrtYn: response[0].mngAuthrtYn,
            regAuthrtYn: response[0].mngAuthrtYn,
            mdfcnAuthrtYn: response[0].mngAuthrtYn,
            delAuthrtYn: response[0].mngAuthrtYn,
          },
        };
      });
    },

    // 시도 변경 이벤트
    initializeCommonData: async () => {
      const promiseSet = await Promise.all([fetchSidoData(), fetchSigunData(), fetchRegionData(), fetchUnitWaterShedData(), fetchMiddleRegionData(), fetchEnvPartData()]);
      const [sidoData, sggData, regionData, unitData, midData, envData] = promiseSet;
      set((state: CommonType) => ({
        ...state,
        Common: {
          ...state.Common,
          selectSidoData: sidoData,
          selectSigunData: sggData,
          selectRegionData: regionData,
          selectMiddleRegionData: midData,
          selectUnitWaterShedData: unitData,
          selectEnvPartData: envData
        }
      }))
    },
  }
}

export type CommonStore = CommonType & CommonAction;