interface ListSubspesialis {
  id: number;
  Kode: string;
  Subspesialis: string;
  FK_daftar_spesialis_ID: number;
  Spesialis: string;
}

interface Surkon {
  idxdaftar:number;
  noSEP:string;
  kodeHFIS:number;
  id_dokter:string;
  kodePoli:string;
  subspesialis:string;
  tglRencanaKontrol:Date;
  user:string;
  kode_diagnosa:string;
  nama_diagnosa:string;
  tipe_surkon:number;
  tipe_rawat:string;
}

interface data{
  Idx_daftar:number;
  Kode_dokter:number;
  Kode_dpjp:number;
  Kode_poli:string;
}

export const useSubspesialisStore = defineStore("Subspesialises", () => {
  const subspesialis_ = ref<any[]>([]);
  const subspesialis = reactive<ListSubspesialis[]>([]);
  const loadSubspesialis = async () => {
    try {
      subspesialis_.value = await $fetch("/api/surkon/get");
    } catch (error) {
      console.error("Failed to load subspesialis:", error);
    }
  };
  const loadSubspesialisData = async () => {
    try {
      const response = await $fetch("/api/subspesialis/get");
      subspesialis.push(...response);
    } catch (error) {
      console.error("Failed to load subspesialis:", error);
    }
      // console.log(payload)
  };
// console.log(subspesialis)
  return {
    subspesialis,
    subspesialis_,
    loadSubspesialis,
    loadSubspesialisData,
  };
});



export const useSubspesialisStorePost = defineStore("SubspesialisProses", () => {
  const surkon = ref<any[]>([]);
  const data_edit = ref<any>(null);
  const proses_edit = async (payload: Record<string, any>) => {
   
    data_edit.value = payload
  };

 

  return {
    surkon,
 
    proses_edit,
    data_edit
  };
});

export const useSurkonStorePost = defineStore("SuratKontrol", () => {
  // Create state for holding users
  const surkon = ref<any[]>([]);
  // const data_edit = ref<any[]>([]);
  const data_edit = ref<any>(null);

  //tabel
  const loadSurKon = async (payload: Record<string, any>) => {
    try {
      surkon.value = await $fetch("/api/surkon/post2", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify(payload)
      });
    } catch (error) {
      console.error("Failed to load surkon:", error);
    }
  };

  const proses_edit = async (payload: Record<string, any>) => {
    data_edit.value = payload
  };

  // simpan
  const simpan_SurKon = async (payload: Record<string, any>) => {
    try {
      // console.log("APA INI")
      surkon.value = await $fetch("/api/surkon/post",{
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        // body: JSON.stringify(payload._value)
        body: JSON.stringify(payload)
      });
    } catch (error) {
      console.error("Failed to load surkon:", error);
    }
      // console.log(payload)
  };

  return {
    surkon,
    data_edit,
    loadSurKon,
    simpan_SurKon,
    proses_edit,
  };
});

export const useDataLogAPIGet = defineStore("DataLogAPI", () => {
  const dataLogAPI = ref<any[]>([]);
  const loadDataLogAPI = async (reqDataLogAPI: Record<string, any>) => {
    try {
      console.log("REQ", reqDataLogAPI)
      dataLogAPI.value = await $fetch("/api/satu_rssa/logapi", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify(reqDataLogAPI)
      });
      console.log(dataLogAPI.value)
    } catch (error) {
      console.error("Failed to load data log api:", error);
    }
  };
  return{
    dataLogAPI,
    loadDataLogAPI,
  }
});

export const useDataLogAPIByMethod = defineStore("DataLogAPIByMethod", () => {
  const dataLogAPIByMethod = ref<any[]>([]);
  const loadDataLogAPI = async (reqDataLogAPI: Record<string, any>) => {
    try {
      console.log("REQ", reqDataLogAPI)
      dataLogAPIByMethod.value = await $fetch("/api/satu_rssa/logapiByMethod", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify(reqDataLogAPI)
      });
      console.log(dataLogAPIByMethod.value)
    } catch (error) {
      console.error("Failed to load data log api:", error);
    }
  };
  return{
    dataLogAPIByMethod,
    loadDataLogAPI,
  }
});

export const useDataKunjunganPasien = defineStore("DataKunjunganPasien", () => {
  const dataKunjunganPasien = ref<any[]>([]);

  const calculateAge = (tanggalLahir: string) => {
    const today = new Date();
    const birthDate = new Date(tanggalLahir);
    
    if (isNaN(birthDate.getTime())) {
      console.error("Tanggal lahir tidak valid:", tanggalLahir);
      return null;
    }

    let age = today.getFullYear() - birthDate.getFullYear();
    const m = today.getMonth() - birthDate.getMonth();

    
    if (m < 0 || (m === 0 && today.getDate() < birthDate.getDate())) {
      age--;
    }

    return age;
  };


  const loadDataKunjunganPasien = async (reqDataKunjunganPasien: Record<string, any>) => {
    try {
      console.log("REQ", reqDataKunjunganPasien);
      const response = await $fetch("/api/satu_rssa/kunjungan_pasien", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },
        body: JSON.stringify(reqDataKunjunganPasien),
      });

      console.log("Response Data:", response);

      
      dataKunjunganPasien.value = response.map((item: any) => {
        const tanggalLahir = item.tanggallahir; 
        const umur = tanggalLahir ? calculateAge(tanggalLahir) : null;

       
        return { ...item, umur };
      });

      console.log("Data Kunjungan Pasien dengan Umur:", dataKunjunganPasien.value);
    } catch (error) {
      console.error("Failed to load data log api:", error);
    }
  };

  return {
    dataKunjunganPasien,
    loadDataKunjunganPasien,
  };
});


export const useJadwalDokter = defineStore("JadwalDokter", () => {
  const JadwalDokter = ref<any[]>([]);
  const loadJadwalDokter = async() => {
    try {
      JadwalDokter.value = await $fetch("/api/satu_rssa/jadwal_dokter")
    } catch (error) {
      console.error("Failed to load jadwal dokter:", error);
    }
  }
  return{
    JadwalDokter,
    loadJadwalDokter,
  }
})

//Path:stores/users.ts
if (import.meta.hot) {
  // import.meta.hot.accept(acceptHMRUpdate(useUsersStore, import.meta.hot))
  import.meta.hot.accept(acceptHMRUpdate(useSubspesialisStore, import.meta.hot));
  import.meta.hot.accept(acceptHMRUpdate(useSubspesialisStorePost, import.meta.hot));
  import.meta.hot.accept(acceptHMRUpdate(useSurkonStorePost, import.meta.hot));
  // import.meta.hot.accept(acceptHMRUpdate(useSurkonStore, import.meta.hot));
}