import { isValidDate } from '~/lib/date'
import { medicalRoles } from '~/const/common/role'

export interface EncounterItem {
  id: string
  title: string
  classCode?: string[]
  unit?: string
  afterId?: string
  component?: any
  props?: Record<string, any>
}

export interface EncounterProps {
  classCode: 'ambulatory' | 'emergency' | 'inpatient' | 'outpatient'
  subClassCode: 'reg' | 'rehab' | 'chemo' | 'emg' | 'eon' | 'op' | 'icu' | 'hcu' | 'vk'
}

export interface EncounterListData {
  encounter?: any
  status?: any
  medicalAssessment?: any
  medicalAssessmentRehab: any
  functionAssessment?: any
  protocolTheraphy?: any
  protocolChemotherapy?: any
  medicineProtocolChemotherapy?: any
  consultation?: any
  letterOfControl?: any
}

const StatusAsync = defineAsyncComponent(() => import('~/components/content/encounter/status.vue'))
const AssesmentFunctionListAsync = defineAsyncComponent(() => import('~/components/content/soapi/entry.vue'))
const EarlyMedicalAssesmentListAsync = defineAsyncComponent(() => import('~/components/content/soapi/entry.vue'))
const EarlyMedicalRehabListAsync = defineAsyncComponent(() => import('~/components/content/soapi/entry.vue'))
const ChemoProtocolListAsync = defineAsyncComponent(() => import('~/components/app/chemotherapy/list.protocol.vue'))
const ChemoMedicineProtocolListAsync = defineAsyncComponent(
  () => import('~/components/app/chemotherapy/list.medicine.vue'),
)
const DeviceOrderAsync = defineAsyncComponent(() => import('~/components/content/device-order/main.vue'))
const PrescriptionAsync = defineAsyncComponent(() => import('~/components/content/prescription/main.vue'))
const CpLabOrderAsync = defineAsyncComponent(() => import('~/components/content/cp-lab-order/main.vue'))
const ProcedureRoomOrderAsync = defineAsyncComponent(() => import('~/components/content/procedure-room-order/main.vue'))
const CprjAsync = defineAsyncComponent(() => import('~/components/content/cprj/entry.vue'))
const RadiologyAsync = defineAsyncComponent(() => import('~/components/content/radiology-order/main.vue'))
const ConsultationAsync = defineAsyncComponent(() => import('~/components/content/consultation/list.vue'))
const DocUploadListAsync = defineAsyncComponent(() => import('~/components/content/document-upload/list.vue'))
const GeneralConsentListAsync = defineAsyncComponent(() => import('~/components/content/general-consent/entry.vue'))
const ResumeListAsync = defineAsyncComponent(() => import('~/components/content/resume/list.vue'))
const ControlLetterListAsync = defineAsyncComponent(() => import('~/components/content/control-letter/list.vue'))

const defaultKeys: Record<string, any> = {
  status: {
    id: 'status',
    title: 'Status Masuk/Keluar',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  earlyNurseryAssessment: {
    id: 'early-nursery-assessment',
    title: 'Pengkajian Awal Keperawatan',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  earlyMedicalAssessment: {
    id: 'early-medical-assessment',
    title: 'Pengkajian Awal Medis',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  earlyMedicalRehabAssessment: {
    id: 'rehab-medical-assessment',
    title: 'Pengkajian Awal Medis Rehabilitasi Medis',
    classCode: ['ambulatory'],
    unit: 'rehab',
    afterId: 'early-medical-assessment',
  },
  functionAssessment: {
    id: 'function-assessment',
    title: 'Asesmen Fungsi',
    classCode: ['ambulatory'],
    unit: 'rehab',
    afterId: 'rehab-medical-assessment',
  },
  therapyProtocol: {
    id: 'therapy-protocol',
    classCode: ['ambulatory'],
    title: 'Protokol Terapi',
    unit: 'rehab',
    afterId: 'function-assessment',
  },
  chemotherapyProtocol: {
    id: 'chemotherapy-protocol',
    title: 'Protokol Kemoterapi',
    classCode: ['ambulatory'],
    unit: 'chemo',
    afterId: 'early-medical-assessment',
  },
  chemotherapyMedicine: {
    id: 'chemotherapy-medicine',
    title: 'Protokol Obat Kemoterapi',
    classCode: ['ambulatory'],
    unit: 'chemo',
    afterId: 'chemotherapy-protocol',
  },
  educationAssessment: {
    id: 'education-assessment',
    title: 'Asesmen Kebutuhan Edukasi',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  generalConsent: {
    id: 'general-consent',
    title: 'General Consent',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  patientAmbNote: {
    id: 'patient-amb-note',
    title: 'CPRJ',
    classCode: ['ambulatory', 'emergency'],
    unit: 'all',
  },
  patientDevNote: {
    id: 'patient-dev-note',
    title: 'CPP',
    classCode: ['inpatient'],
    unit: 'all',
  },
  prescription: {
    id: 'prescription',
    title: 'Order Obat',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  deviceOrder: {
    id: 'device-order',
    title: 'Order Alkes',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  radiologyOrder: {
    id: 'radiology-order',
    title: 'Order Radiologi',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  cpLabOrder: {
    id: 'cp-lab-order',
    title: 'Order Lab PK',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  microLabOrder: {
    id: 'micro-lab-order',
    title: 'Order Lab Mikro',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  paLabOrder: {
    id: 'pa-lab-order',
    title: 'Order Lab PA',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  procedureRoomOrder: {
    id: 'procedure-room-order',
    title: 'Order Ruang Tindakan',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  mcuResult: {
    id: 'mcu-result',
    title: 'Hasil Penunjang',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  actionReport: {
    id: 'action-report',
    title: 'Laporan Tindakan',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  surgeryReport: {
    id: 'surgery-report',
    title: 'Laporan Operasi',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  vacsinData: {
    id: 'vacsin-data',
    title: 'Data Vaksin',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  consultation: {
    id: 'consultation',
    title: 'Konsultasi',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  controlLetter: {
    id: 'control-letter',
    title: 'Surat Kontrol',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  inpatientLetter: {
    id: 'inpatient-letter',
    title: 'SPRI',
    classCode: ['ambulatory', 'emergency'],
    unit: 'all',
  },
  refBack: {
    id: 'reference-back',
    title: 'PRB',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  screening: {
    id: 'screening',
    title: 'Skrinning MPP',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  supportingDocument: {
    id: 'supporting-document',
    title: 'Upload Dokumen Pendukung',
    classCode: ['ambulatory'],
    unit: 'all',
  },
  resume: {
    id: 'resume',
    title: 'Resume',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  ambResume: {
    id: 'amb-resume',
    title: 'Resume Medis Rawat Jalan',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
  priceList: {
    id: 'price-list',
    title: 'Tarif Tindakan',
    classCode: ['ambulatory', 'emergency', 'inpatient'],
    unit: 'all',
  },
}

export function getItemsByClassCode(classCode: string, items: EncounterItem[]) {
  return items.filter((item) => item.classCode?.includes(classCode))
}

export function getItemsByUnit(unit: string, items: EncounterItem[]) {
  return items.filter((item) => item.unit === unit)
}

export function getItemsByIds(ids: string[], items: EncounterItem[]) {
  return items.filter((item) => ids.includes(item.id))
}

export function getIndexById(id: string, items: EncounterItem[]) {
  return items.findIndex((item) => item.id === id)
}

export const getItemsAll = (classCode: string, unit: string, items: EncounterItem[]) => {
  const prevItems = [...items]
  let updateItems = getItemsByClassCode(classCode, prevItems)
  updateItems = getItemsByUnit(unit, updateItems)
  return updateItems
}

export function insertItemByAfterId(id: string, items: EncounterItem[], newItem: EncounterItem) {
  const index = getIndexById(id, items)
  if (index > -1) {
    items.splice(index + 1, 0, newItem)
  }
}

export function injectComponents(id: string | number, data: EncounterListData, meta: EncounterListData) {
  const currentKeys = { ...defaultKeys }
  if (currentKeys?.status) {
    currentKeys.status['component'] = StatusAsync
    currentKeys.status['props'] = { encounter: data?.encounter }
  }
  if (currentKeys?.earlyMedicalAssessment) {
    currentKeys.earlyMedicalAssessment['component'] = EarlyMedicalAssesmentListAsync
    currentKeys.earlyMedicalAssessment['props'] = {
      encounter: data?.encounter,
      type: 'early-medic',
      label: currentKeys.earlyMedicalAssessment['title'],
    }
  }
  if (currentKeys?.earlyMedicalRehabAssessment) {
    currentKeys.earlyMedicalRehabAssessment['component'] = EarlyMedicalRehabListAsync
    currentKeys.earlyMedicalRehabAssessment['props'] = {
      encounter: data?.encounter,
      type: 'early-rehab',
      label: currentKeys.earlyMedicalRehabAssessment['title'],
    }
  }
  if (currentKeys?.functionAssessment) {
    currentKeys.functionAssessment['component'] = AssesmentFunctionListAsync
    currentKeys.functionAssessment['props'] = {
      encounter: data?.encounter,
      type: 'function',
      label: currentKeys.functionAssessment['title'],
    }
  }
  if (currentKeys?.therapyProtocol) {
    // TODO: add component for therapyProtocol
    currentKeys.therapyProtocol['component'] = null
    currentKeys.therapyProtocol['props'] = {
      data: data?.encounter,
      paginationMeta: meta?.protocolTheraphy,
    }
  }
  if (currentKeys?.chemotherapyProtocol) {
    currentKeys.chemotherapyProtocol['component'] = ChemoProtocolListAsync
    currentKeys.chemotherapyProtocol['props'] = {
      data: data?.encounter,
      paginationMeta: meta?.protocolChemotherapy,
    }
  }
  if (currentKeys?.chemotherapyMedicine) {
    currentKeys.chemotherapyMedicine['component'] = ChemoMedicineProtocolListAsync
    currentKeys.chemotherapyMedicine['props'] = {
      data: data?.encounter,
      paginationMeta: meta?.medicineProtocolChemotherapy,
    }
  }
  if (currentKeys?.educationAssessment) {
    // TODO: add component for education assessment
    currentKeys.educationAssessment['component'] = null
    currentKeys.educationAssessment['props'] = { encounter_id: id }
  }
  if (currentKeys?.generalConsent) {
    currentKeys.generalConsent['component'] = GeneralConsentListAsync
    currentKeys.generalConsent['props'] = { encounter_id: id }
  }
  if (currentKeys?.patientAmbNote) {
    currentKeys.patientAmbNote['component'] = CprjAsync
    currentKeys.patientAmbNote['props'] = { encounter_id: id }
  }
  if (currentKeys?.prescription) {
    currentKeys.prescription['component'] = PrescriptionAsync
    currentKeys.prescription['props'] = { encounter_id: id }
  }
  if (currentKeys?.deviceOrder) {
    currentKeys.deviceOrder['component'] = DeviceOrderAsync
    currentKeys.deviceOrder['props'] = { encounter_id: id }
  }
  if (currentKeys?.radiologyOrder) {
    currentKeys.radiologyOrder['component'] = RadiologyAsync
    currentKeys.radiologyOrder['props'] = { encounter_id: id }
  }
  if (currentKeys?.cpLabOrder) {
    currentKeys.cpLabOrder['component'] = CpLabOrderAsync
    currentKeys.cpLabOrder['props'] = { encounter_id: id }
  }
  if (currentKeys?.microLabOrder) {
    // TODO: add component for microLabOrder
    currentKeys.microLabOrder['component'] = null
    currentKeys.microLabOrder['props'] = { encounter_id: id }
  }
  if (currentKeys?.paLabOrder) {
    // TODO: add component for paLabOrder
    currentKeys.paLabOrder['component'] = null
    currentKeys.paLabOrder['props'] = { encounter_id: id }
  }
  if (currentKeys?.procedureRoomOrder) {
    currentKeys.procedureRoomOrder['component'] = ProcedureRoomOrderAsync
    currentKeys.procedureRoomOrder['props'] = { encounter_id: id }
  }
  if (currentKeys?.mcuResult) {
    // TODO: add component for mcuResult
    currentKeys.mcuResult['component'] = null
    currentKeys.mcuResult['props'] = { encounter_id: id }
  }
  if (currentKeys?.consultation) {
    currentKeys.consultation['component'] = ConsultationAsync
    currentKeys.consultation['props'] = { encounter: data?.encounter }
  }
  if (currentKeys?.resume) {
    currentKeys.resume['component'] = ResumeListAsync
    currentKeys.resume['props'] = { encounter_id: id }
  }
  if (currentKeys?.control) {
    currentKeys.control['component'] = ControlLetterListAsync
    currentKeys.control['props'] = { encounter: data?.encounter }
  }
  if (currentKeys?.screening) {
    // TODO: add component for screening
    currentKeys.screening['component'] = null
    currentKeys.screening['props'] = { encounter_id: id }
  }
  if (currentKeys?.supportingDocument) {
    currentKeys.supportingDocument['component'] = DocUploadListAsync
    currentKeys.supportingDocument['props'] = { encounter_id: id }
  }
  if (currentKeys?.priceList) {
    // TODO: add component for priceList
    currentKeys.priceList['component'] = null
    currentKeys.priceList['props'] = { encounter_id: id }
  }

  return currentKeys
}

export function mergeArrayAt<T>(arraysOne: T[], arraysTwo: T[] | T, deleteCount = 0): T[] {
  const prevItems = arraysOne.slice()
  if (!prevItems) return prevItems
  const nextItems = Array.isArray(arraysTwo) ? arraysTwo : [arraysTwo]
  if (nextItems.length === 0) return prevItems
  // determine insertion position using the first item's `id` if available
  const firstId = (nextItems[0] as any)?.afterId || (prevItems[0] as any)?.id
  let pos = prevItems.length
  if (typeof firstId === 'string') {
    const index = prevItems.findIndex((item: any) => item.id === firstId)
    pos = index < 0 ? Math.max(prevItems.length + index, 0) : Math.min(index, prevItems.length)
  }
  prevItems.splice(pos, deleteCount, ...nextItems)
  return prevItems
}

// Function to map API response to Encounter structure
export function mapResponseToEncounter(result: any): any {
  if (!result) return null

  // Check if patient and patient.person exist (minimal validation)
  if (!result.patient || !result.patient.person) {
    return null
  }

  const mapped: any = {
    id: result.id || 0,
    patient_id: result.patient_id || result.patient?.id || 0,
    patient: {
      id: result.patient?.id || 0,
      number: result.patient?.number || '',
      person: {
        id: result.patient?.person?.id || 0,
        name: result.patient?.person?.name || '',
        birthDate: result.patient?.person?.birthDate || null,
        gender_code: result.patient?.person?.gender_code || '',
        residentIdentityNumber: result.patient?.person?.residentIdentityNumber || null,
        frontTitle: result.patient?.person?.frontTitle || '',
        endTitle: result.patient?.person?.endTitle || '',
        addresses: result.patient?.person?.addresses || [],
      },
    },
    registeredAt: result.registeredAt || result.patient?.registeredAt || null,
    class_code: result.class_code || '',
    unit_id: result.unit_id || 0,
    unit: result.unit || null,
    specialist_id: result.specialist_id || null,
    subspecialist_id: result.subspecialist_id || null,
    visitDate: isValidDate(result.visitDate)
      ? result.visitDate
      : result.registeredAt || result.patient?.registeredAt || null,
    adm_employee_id: result.adm_employee_id || 0,
    appointment_doctor_id: result.appointment_doctor_id || null,
    responsible_doctor_id: result.responsible_doctor_id || null,
    appointment_doctor: result.appointment_doctor || null,
    responsible_doctor: result.responsible_doctor || null,
    refSource_name: result.refSource_name || null,
    appointment_id: result.appointment_id || null,
    earlyEducation: result.earlyEducation || null,
    medicalDischargeEducation: result.medicalDischargeEducation || '',
    admDischargeEducation: result.admDischargeEducation || null,
    discharge_method_code: result.discharge_method_code || null,
    discharge_reason: result.dischargeReason || result.discharge_reason || null,
    discharge_date: result.discharge_date || null,
    status_code: result.status_code || '',
    // Payment related fields
    paymentMethod_code:
      result.paymentMethod_code && result.paymentMethod_code.trim() !== '' ? result.paymentMethod_code : null,
    trx_number: result.trx_number || null,
    member_number: result.member_number || null,
    ref_number: result.ref_number || null,
  }

  return mapped
}

export function getMenuItems(
  id: string | number,
  props: any,
  user: any,
  data: EncounterListData,
  meta: any,
) {
  console.log(props)
  // const normalClassCode = props.classCode === 'ambulatory' ? 'outpatient' : props.classCode
  const normalClassCode = props.classCode === 'ambulatory' ? 'ambulatory' : props.classCode
  const currentKeys = injectComponents(id, data, meta)
  const defaultItems: EncounterItem[] = Object.values(currentKeys)
  const listItemsForOutpatientRehab = mergeArrayAt(
    getItemsAll('ambulatory', 'all', defaultItems),
    getItemsAll('ambulatory', 'rehab', defaultItems),
  )
  const listItemsForOutpatientChemo = mergeArrayAt(
    getItemsAll('ambulatory', 'all', defaultItems),
    getItemsAll('ambulatory', 'chemo', defaultItems),
  )
  const listItems: Record<string, Record<string, Record<string, any>>> = {
    'installation|ambulatory': {
      'unit|rehab': {
        items: listItemsForOutpatientRehab,
        roles: medicalRoles,
      },
      'unit|chemo': {
        items: listItemsForOutpatientChemo,
        roles: medicalRoles,
      },
      all: getItemsAll('ambulatory', 'all', defaultItems),
    },
    'installation|emergency': {
      all: getItemsAll('emergency', 'all', defaultItems),
    },
    'installation|inpatient': {
      all: getItemsAll('inpatient', 'all', defaultItems),
    },
  }
  const currentListItems = listItems[`installation|${normalClassCode}`]
  if (!currentListItems) return []
  const unitCode = user?.unit_code ? `unit|${user.unit_code}` : 'all'
  const currentUnitItems: any = currentListItems[`${unitCode}`]
  if (!currentUnitItems) return []
  let menus = []
  if (currentUnitItems.roles && currentUnitItems.roles?.includes(user.activeRole)) {
    menus = [...currentUnitItems.items]
  } else {
    menus = unitCode !== 'all' && currentUnitItems?.items ? [...currentUnitItems.items] : [...currentUnitItems]
  }
  return menus
}