export {}

declare global {
  type DrugUnit = 'g' | 'mg' | 'mcg'
  type LocalDoseUnit = 'ml' | 'mg' | 'cartridges'

  type ParenDrugRoute = 'IV' | 'IM' | 'IN' | 'IMAD'
  type InfusionRoute = 'infusion' | 'infusionBolus'
  type FluidRoute = 'fluid' | 'fluidBolus' | 'syringeFlush'
  type OralSedativeRoute = 'PO' | 'SL'
  type PreProcedureSedativeRoute = OralSedativeRoute | 'IM' | 'IN'

  type InfusionUnit = 'mcg/kg/min' | 'mcg/kg/hr' | 'mcg/min' | 'mg/hr'
  type InfusionBolusUnit = 'mcg' | 'mg' | 'mcg/kg'
  type InfusionTotalUnit = 'mcg' | 'mg'

  type LocalAnestheticUnit = 'cartridges' | 'ml' | 'mg'

  type LocalDrug = {
    id: string
    name: string
    epi: number
    percent: number
  }

  type OralSedative = {
    id: string
    name: string
    unit: DrugUnit
  }

  type ParenDrug = {
    id: string
    name: string
    unit: DrugUnit
  }

  type InfusionDrug = {
    id: string
    name: string
  }

  type InhalationUnit = 'L/min' | '%'

  type InhalationAgent = {
    id: string
    name: string
    color: string
    unit: InhalationUnit
    step: number
    /**
     * @remarks
     *   We hardcode this because we want `sortOrder` to be available and included
     *   both in the type and when using the lookup by id.
     */
    sortOrder: number
    max: number
    isAA?: true
    deepGaOnly?: true
  }

  type ParenDrugDosageBase = {
    time: number
    amount_raw?: string
    wasted_raw?: string
    drawAmountTemp_raw?: string
    totalDrawn_raw?: string
    wasteConfirmed?: boolean
    route?: ParenDrugRoute
    meta?: string
  }

  type ParenDrugDosageProcessed = {
    amount?: number
    wasted?: number
    drawAmountTemp?: number
    totalDrawn?: number
  } & ParenDrugDosageBase

  type ParenDrugDosage = {
    id: string
  } & ParenDrugDosageProcessed

  type InfusionDrugDosageBase = {
    time: number
    amount_raw?: string
    wasted_raw?: string
    used_raw?: string
    route?: InfusionRoute
    unit?: InfusionUnit
    bolusUnit?: InfusionBolusUnit
    wasteConfirmed?: boolean
    totalUnit?: InfusionTotalUnit
    kg?: string
    meta?: string
  }

  type InfusionDrugDosageProcessed = {
    amount?: number
    wasted?: number
    used?: number
  } & InfusionDrugDosageBase

  type InfusionDrugDosage = {
    id: string
    name: string
  } & InfusionDrugDosageProcessed

  type SelectedInfusionDrug = {
    name: string
    bolusUnitOptions: InfusionBolusUnit[]
    /**
     * @remarks
     *   The difference between `kg` and `pumpKg` is that `kg` is the raw value
     *   from the input field (with no defaults). Whereas `pumpKg` is either a
     *   number value or null. If the input field is empty, it will fallback to
     *   using the patient's weight. So it's possible to have a `pumpKg` but no
     *   `kg` value.
     */
    pumpKg: number | null
    unitNeedsKg: boolean
  } & InfusionDrugDosage

  type InfusionDrugReport = {
    id: string
    name: string
    total?: number
    wasted?: number
    totalUnit: InfusionTotalUnit
    pumpKg: number | null
    unit: InfusionUnit
    bolusUnit: InfusionBolusUnit
    boluses: InfusionDoseAdministered[]
    infusions: InfusionDoseAdministered[]
  }

  type ParenDrugReportDose = {
    id: string
    amount: number
    amount_raw: string
    pctOfMax: number
    unit: DrugUnit
    time: number
    route: ParenDrugRoute
    isPreProcedure: boolean
    /**
     * @remarks
     *   This is a string because it includes units. It is only included if we
     *   have a patient weight. Which we may not at all times.
     */
    perKg?: string
  }

  type ParenDrugReport = {
    id: string
    name: string
    unit: DrugUnit
    total: number
    wasted: number
    maxDose: number
    givenDuringProcedure: number
    doses: ParenDrugReportDose[]
  }

  type InhalationReport = {
    id: string
    name: string
    step: number
    max: number
    color: string
    unit: InhalationUnit
    isAA: boolean
    currentDose: number
    hasBeenUsed: boolean
    records: {
      id: string
      time: number
      amount: number
    }[]
  }

  type OralSedativeReportDose = {
    id: string
    amount: number
    pctOfMax: number
    unit: DrugUnit
    time: number
    route: OralSedativeRoute
    isPreProcedure: boolean
    isComplete: boolean
    /**
     * @remarks
     *   This is a string because it includes units. It is only included if we
     *   have a patient weight. Which we may not at all times.
     */
    perKg?: string
  }

  type OralSedativeReport = {
    id: string
    name: string
    unit: DrugUnit
    total: number
    maxDose: number
    givenDuringProcedure: number
    doses: OralSedativeReportDose[]
  }

  type PreProcedureSedativeReport = {
    id: string
    name: string
    amount: number
    unit: DrugUnit
    route: PreProcedureSedativeRoute
    time: number
  }

  type OralDrugDosageBase = {
    time: number
    amount_raw?: string
    route?: OralSedativeRoute
  }

  type OralDrugDosageProcessed = {
    amount?: number
  } & OralDrugDosageBase

  type OralDrugDosage = {
    id: string
  } & OralDrugDosageProcessed

  type LocalDrugDosageBase = {
    time: number
    amount_raw: string
    unit: LocalDoseUnit
  }

  type LocalDrugDosageProcessed = {
    amount?: number
  } & LocalDrugDosageBase

  type LocalDrugDosage = {
    id: string
  } & LocalDrugDosageProcessed

  type InhalationDosageProcessed = {
    time: number
    amount?: number
  }

  type InhalationDosage = {
    id: string
  } & InhalationDosageProcessed

  type ParenDoseAdministered = {
    id: string
    amount: number
    amount_raw: string
    drugId: string
    // if it's a pre-procedure dose,
    // this could be "editing" also
    editing?: boolean
    route: ParenDrugRoute
    shouldStartCase: true
    time: number
    unit?: DrugUnit
    isComplete: boolean
    isPreProcedure: boolean
  }

  type OralDoseAdministered = {
    id: string
    amount: number
    amount_raw: string
    drugId: string
    editing: boolean
    route: OralSedativeRoute
    shouldStartCase: boolean
    time: number
    unit: DrugUnit
    isComplete: boolean
    isPreProcedure: boolean
  }

  type PreProcedureSedative = {
    id: string
    name: string
    unit: DrugUnit
    availableRoutes: PreProcedureSedativeRoute[]
    common: boolean
  }

  type PreProcedureSedativeDose = (
    | ParenDoseAdministered
    | OralDoseAdministered
  ) & {
    route: PreProcedureSedativeRoute
    isPreProcedure: true
  }

  type PreProcedureSedativeDoseWithDrug = PreProcedureSedativeDose & {
    drug: {
      name: string
      unit: DrugUnit
    }
  }

  type LocalDoseAdministeredRaw = {
    id: string
    amount_raw: string
    amount: number
    drugVariantId: string
    epiConcentration: number
    route: 'local'
    shouldStartCase: false
    time: number
    unit: LocalDoseUnit
  }

  type LocalDoseProcessed = Omit<LocalDoseAdministeredRaw, 'route'> & {
    cartridges: number
    epiMg: number
    mg: number
    skipForToxicity: boolean
  }

  type LocalAnestheticBase = {
    id: string
    name: string
    nameForChart?: string
    altName?: string
    reminder?: string
    percent: number
    halfLife?: number
    input: 'cartridges' | 'mg'
    variants: LocalAnestheticVariantBase[]
  }

  type LocalAnestheticVariantBase = {
    id: string
    color: string
    // can be used to override the parent's rxcui
    rxcui?: string
    manAbsoluteMax?: number
    manRatioMax?: number
    nameForChart?: string
    // normally we build this from epi concentration, but we can override it
    // by providing a value here
    unitForChart?: string
    subName?: string
    epi?: number
    minAge?: number
    enableDilute?: boolean
    aapdAbsoluteMax?: number
    aapdRatioMax?: number
    ageWarning?: string
    noEpiWarning?: string
    skipForToxicity?: boolean
    // if the percent of the variant is different from the parent
    // we can override it.
    percent?: number
    countries?: ('US' | 'AUS')[]
  }

  type LocalAnestheticVariantProcessed = Omit<LocalAnestheticBase, 'variants'> &
    Omit<LocalAnestheticVariantBase, 'countries'>

  type LocalDilutionEntry = CaseData['laDilutions'] & {
    id: string
    percent: number
  }

  type LocalAnestheticVariant = LocalAnestheticVariantProcessed & {
    nameWithPct: string
    subName: string
    rxcui: string
    custom?: boolean
    selected: boolean
    // this is different than unit, this is how they come packaged
    input: 'cartridges' | 'mg'
    unit?: LocalAnestheticUnit
    amount_raw?: string
    amount?: number
    totalMgGiven: number
    totalCartridgesGiven: number
    totalEpiMgGiven: number
    inUse: boolean
    doses: LocalDoseProcessed[]
  }

  type LocalDoseReportEntry = {
    id: string
    drugName: string
    time: number
    mg: number
    epiMg: number
  }

  type InhalationDoseAdministered = {
    id: string
    amount: number
    drugId: string
    route: 'inhalation'
    shouldStartCase: boolean
    time: number
  }

  type InfusionDoseAdministered = {
    id: string
    amount_raw: string
    amount: number
    drugId: string
    route: InfusionRoute
    shouldStartCase: boolean
    time: number
  }

  type FluidDoseAdministered = {
    id: string
    amount_raw: string
    amount: number
    drugId: string
    siteId: string
    bagId?: string
    route: FluidRoute
    time: number
  }

  type DoseAdministered =
    | ParenDoseAdministered
    | OralDoseAdministered
    | LocalDoseAdministeredRaw
    | InhalationDoseAdministered
    | InfusionDoseAdministered
    | FluidDoseAdministered
}