import { create } from 'zustand';
import {
  TempoProps,
  TempoPropsKontakPerson,
  TempoPropsPengiriman,
  TempoPropsSupplier,
  TempoPropsDokumen,
} from '~/types/tempo';
import {
  TempoSchema,
  TempoSchemaKontakPerson,
  TempoSchemaPengiriman,
  TempoSchemaSupplier,
  TempoSchemaDokumen,
} from '~/validations/tempo';
import { boolean, ZodError } from 'zod';

type State = {
  form: TempoProps;
  errors: {
    [key in keyof TempoProps]?: string;
  };
  isCheckedTNC: boolean;
  isOpenTNC: boolean;
  isValidCaptcha: boolean;
};

type Action = {
  updateForm: (name: string, value: string) => void;
  updateValidCaptcha: (value: boolean) => void;
  toggleCheckTNC: () => void;
  openTNC: () => void;
  closeTNC: () => void;
  validate: () => void;
  resetForm: () => void;
};

export const usePengajuanTempoStore = create<State & Action>((set, get) => ({
  form: {
    name: '',
    industryId: '',
    street: '',
    state: '',
    city: '',
    district: '',
    subDistrict: '',
    zip: '',
    mobile: '',
    bankName: '',
    accountName: '',
    accountNumber: '',
    estimasi: '',
    tempoDuration: '',
    bersedia: '',
    portal: '',
    website: '',
    categoryProduk: '',
    tempoLimit: '',
  },
  updateForm: (name, value) =>
    set((state) => ({ form: { ...state.form, [name]: value } })),

  errors: {},
  validate: () => {
    try {
      TempoSchema.parse(get().form);
      set({ errors: {} });
    } catch (error) {
      if (error instanceof ZodError) {
        const errors: State['errors'] = {};
        error.errors.forEach(
          (e) => (errors[e.path[0] as keyof TempoProps] = e.message)
        );
        set({ errors });
      }
    }
  },

  isCheckedTNC: false,
  toggleCheckTNC: () => set((state) => ({ isCheckedTNC: !state.isCheckedTNC })),

  isOpenTNC: false,
  openTNC: () => set(() => ({ isOpenTNC: true })),
  closeTNC: () => set(() => ({ isOpenTNC: false })),

  isValidCaptcha: false,
  updateValidCaptcha: (value) => set(() => ({ isValidCaptcha: value })),

  resetForm: () =>
    set({
      form: {
        name: '',
        industryId: '',
        street: '',
        state: '',
        city: '',
        district: '',
        subDistrict: '',
        zip: '',
        mobile: '',
        bankName: '',
        accountName: '',
        accountNumber: '',
        website: '',
        estimasi: '',
        tempoDuration: '',
        bersedia: '',
        portal: '',
        categoryProduk: '',
      },
    }),
}));

type StateKontakPerson = {
  formKontakPerson: TempoPropsKontakPerson;
  errorsKontakPerson: {
    [key in keyof TempoPropsKontakPerson]?: string;
  };
};
type ActionKontakPerson = {
  updateFormKontakPerson: (name: string, value: string) => void;

  validateKontakPerson: () => void;
};
export const usePengajuanTempoStoreKontakPerson = create<
  StateKontakPerson & ActionKontakPerson
>((set, get) => ({
  formKontakPerson: {
    direkturTittle: '',
    direkturName: '',
    direkturMobile: '',
    direkturEmail: '',
    purchasingTittle: '',
    purchasingName: '',
    purchasingEmail: '',
    financeMobile: '',
    financeTittle: '',
    financeName: '',
    financeEmail: '',
    purchasingMobile: '',
  },
  updateFormKontakPerson: (name, value) =>
    set((state) => ({
      formKontakPerson: { ...state.formKontakPerson, [name]: value },
    })),

  errorsKontakPerson: {},
  validateKontakPerson: () => {
    try {
      TempoSchemaKontakPerson.parse(get().formKontakPerson);
      set({ errorsKontakPerson: {} });
    } catch (error) {
      if (error instanceof ZodError) {
        const errorsKontakPerson: StateKontakPerson['errorsKontakPerson'] = {};
        error.errors.forEach(
          (e) =>
            (errorsKontakPerson[e.path[0] as keyof TempoPropsKontakPerson] =
              e.message)
        );
        set({ errorsKontakPerson });
      }
    }
  },
}));

type StatePengiriman = {
  formPengiriman: TempoPropsPengiriman;
  errorsPengiriman: {
    [key in keyof TempoPropsPengiriman]?: string;
  };
};
type ActionPengiriman = {
  updateFormPengiriman: (name: string, value: string) => void;
  updateDokumenProsedur: (name: string, format: string, base64: string) => void;
  validatePengiriman: () => void;
};
export const usePengajuanTempoStorePengiriman = create<
  StatePengiriman & ActionPengiriman
>((set, get) => ({
  formPengiriman: {
    PICTittle: '',
    PICName: '',
    streetPengiriman: '',
    statePengiriman: '',
    cityPengiriman: '',
    districtPengiriman: '',
    subDistrictPengiriman: '',
    zipPengiriman: '',
    PICBarangMobile: '',
    invoicePicMobile: '',
    invoicePicTittle: '',
    invoicePic: '',
    isSameAddrees: '',
    isSameAddreesStreet: '',
    streetInvoice: '',
    stateInvoice: '',
    cityInvoice: '',
    districtInvoice: '',
    subDistrictInvoice: '',
    zipInvoice: '',
    tukarInvoiceInput: '',
    tukarInvoiceInputPembayaran: '',
    dokumenPengiriman: '',
    dokumenPengirimanInput: '',
    dokumenKirimInput: '',
    dokumenPengirimanInvoice: '',
    dokumenProsedur: { name: '', format: '', base64: '' },
  },
  updateFormPengiriman: (name, value) =>
    set((state) => ({
      formPengiriman: { ...state.formPengiriman, [name]: value },
    })),

  updateDokumenProsedur: (name, format, base64) =>
    set((state) => ({
      formPengiriman: {
        ...state.formPengiriman,
        dokumenProsedur: { name, format, base64 },
      },
    })),

  errorsPengiriman: {},
  validatePengiriman: () => {
    try {
      TempoSchemaPengiriman.parse(get().formPengiriman);
      set({ errorsPengiriman: {} });
    } catch (error) {
      if (error instanceof ZodError) {
        const errorsPengiriman: StatePengiriman['errorsPengiriman'] = {};
        error.errors.forEach(
          (e) =>
            (errorsPengiriman[e.path[0] as keyof TempoPropsPengiriman] =
              e.message)
        );
        set({ errorsPengiriman });
      }
    }
  },
}));
type StateDokumen = {
  formDokumen: TempoPropsDokumen;
  errorsDokumen: {
    [key in keyof TempoPropsDokumen]?: string;
  };
};
type ActionDokumen = {
  updateFormDokumen: (
    name: string,
    fileName: string,
    fileFormat: string,
    value: string
  ) => void;

  validateDokumen: () => void;
  getJumlahDokumenDiisi: () => void;
};
export const usePengajuanTempoStoreDokumen = create<
  StateDokumen & ActionDokumen
>((set, get) => ({
  formDokumen: {
    dokumenNib: { name: '', format: '', base64: '' },
    dokumenNpwp: { name: '', format: '', base64: '' },
    dokumenSppkp: { name: '', format: '', base64: '' },
    dokumenSiup: { name: '', format: '', base64: '' },
    dokumenTdp: { name: '', format: '', base64: '' },
    dokumenSkdp: { name: '', format: '', base64: '' },
    dokumenSkt: { name: '', format: '', base64: '' },
    dokumenAktaPerubahan: { name: '', format: '', base64: '' },
    dokumenKtpDirut: { name: '', format: '', base64: '' },
    dokumenAktaPendirian: { name: '', format: '', base64: '' },
    dokumenLaporanKeuangan: { name: '', format: '', base64: '' },
    dokumenFotoKantor: { name: '', format: '', base64: '' },
    dokumenTempatBekerja: { name: '', format: '', base64: '' },
    dokumenProsedur: { name: '', format: '', base64: '' },
  },

  // Memperbarui dokumen dengan name, format, dan base64
  updateFormDokumen: (name, fileName, fileFormat, value) =>
    set((state) => ({
      formDokumen: {
        ...state.formDokumen,
        [name]: {
          name: fileName,
          format: fileFormat,
          base64: value,
        },
      },
    })),

  errorsDokumen: {},
  validateDokumen: () => {
    try {
      TempoSchemaDokumen.parse(get().formDokumen);
      set({ errorsDokumen: {} });
    } catch (error) {
      if (error instanceof ZodError) {
        const errorsDokumen: StateDokumen['errorsDokumen'] = {};
        error.errors.forEach(
          (e) =>
            (errorsDokumen[e.path[0] as keyof TempoPropsDokumen] = e.message)
        );
        set({ errorsDokumen });
      }
    }
  },

  getJumlahDokumenDiisi: () => {
    const formDokumen = get().formDokumen;
    // Menghitung jumlah field yang base64 tidak kosong
    const jumlahTerisi = Object.values(formDokumen).filter(
      (dokumen) => dokumen.base64 !== ''
    ).length;
    return jumlahTerisi;
  },
}));

type StateSupplier = {
  hasSavedata: boolean;
  formSupplier: [];
  errorsSupplier: {
    [key in keyof TempoPropsSupplier]?: string;
  };
};
type ActionSupplier = {
  updateFormSupplier: (data: []) => void;
  updateHasSave: (data: boolean) => void;
  validateSupplier: () => void;
};
export const usePengajuanTempoStoreSupplier = create<
  StateSupplier & ActionSupplier
>((set, get) => ({
  formSupplier: [],
  hasSavedata: true,
  updateFormSupplier: (data) => {
    set(() => ({
      formSupplier: data,
    }));
  },
  updateHasSave: (data) => {
    set(() => ({
      hasSavedata: data,
    }));
  },
  errorsSupplier: {},
  validateSupplier: () => {},
}));