import React, { useState, useEffect } from 'react';
import { TextareaControl } from "../ui/textarea-control";
import { Card, CardHeader, CardBody, CardDivider } from '../ui/wp-card';
import { Elevation } from '../ui/elevation';
import { InputControl } from '../ui/input-control';
import { Divider } from '../ui/divider';
import { DismissibleAlert } from '../ui/dismissible-alert';
import { Heading } from '../ui/heading';
import { Flex, FlexItem } from '../ui/flex';
import { Spacer } from '../ui/spacer';
import { TabPanel } from '../ui/tab-panel';
import { useFormContext, Controller, useFieldArray } from 'react-hook-form';
import { IValueSet, useAuthServiceContext, useValueSetServiceContext } from '../../services';
import {
    FhirCode,
    FhirCodeableConcept,
    FhirReference,
    FhirReferenceCollection
} from '../../components';
import {
    useFhirAdverseEventBroadcast,
    useFhirAdverseEvents,
    useFhirAllergyIntolerances,
    useFhirConditions,
    useFhirDevices,
    useFhirEncounters,
    useFhirFamilyMemberHistories,
    useFhirImmunizations,
    useFhirLocations,
    useFhirMedicationAdministrations,
    useFhirMedicationStatements,
    useFhirObservations, useFhirPractitioners,
    useFhirProcedures
} from '../../hooks';
import FhirValueSetSearch from '../FhirValueSetSearch/FhirValueSetSearch.tsx';
import { PlusCircle, Trash2 } from 'lucide-react';
import { FhirResource } from 'fhir/r4';

interface FhirImmunizationEvaluationProps {
    elevated?: boolean;
    disabled?: boolean;
    enableInlineActions?: boolean;
}

const SuspectEntityInstanceReferences: React.FC<{ index: number; disabled: boolean; enableInlineActions: boolean }> = ({ index, disabled, enableInlineActions = true }) => {
    const { control } = useFormContext();
    const itemReferenceFieldArray = useFieldArray({ control, name: `suspectEntity.${index}.instance` });

    const { devicesList } = useFhirDevices();
    const { immunizationsList } = useFhirImmunizations();
    const { proceduresList } = useFhirProcedures();
    const { medicationAdministrationsList } = useFhirMedicationAdministrations();
    const { medicationStatementsList } = useFhirMedicationStatements();

    return (
        <FhirReferenceCollection label="Instance"
                                 references={itemReferenceFieldArray}
                                 context={`suspectEntity.${index}.instance`}
                                 referenceTypes={[
                                     { name: 'Immunization', key: 'Immunization' },
                                     { name: 'Procedure', key: 'Procedure' },
                                     { name: 'MedicationAdministration', key: 'MedicationAdministration' },
                                     { name: 'MedicationStatement', key: 'MedicationStatement' },
                                     { name: 'Device', key: 'Device' }
                                 ]}
                                 getReferenceList={(referenceType: string): FhirResource[] => {
                                     switch (referenceType) {
                                         case 'Immunization':
                                             return immunizationsList;
                                         case 'Procedure':
                                             return proceduresList;
                                         case 'MedicationAdministration':
                                             return medicationAdministrationsList;
                                         case 'MedicationStatement':
                                             return medicationStatementsList;
                                         case 'Device':
                                             return devicesList;
                                         default:
                                             return [];
                                     }
                                 }}
                                 required={false}
                                 disabled={disabled}
                                 multiple={false}
                                 enableInlineActions={enableInlineActions}/>
    );
};

export const FhirAdverseEvent: React.FC<FhirImmunizationEvaluationProps> = ({ elevated = true, disabled = false, enableInlineActions = true }) => {
    const { control, watch, setValue, getValues } = useFormContext();
    const { fetchValueSet, valueSetUrls } = useValueSetServiceContext();
    const { userRole, USER_ROLES } = useAuthServiceContext();
    const isPatientRole = [USER_ROLES.PATIENT, USER_ROLES.RELATED_PERSON].includes(userRole as string);

    const [loading, setLoading] = useState(false);

    // value sets
    const [adverseEventActuality, setAdverseEventActuality] = useState<IValueSet[]>([]);
    const [adverseEventCategory, setAdverseEventCategory] = useState<IValueSet[]>([]);
    const [adverseEventSeriousness, setAdverseEventSeriousness] = useState<IValueSet[]>([]);
    const [adverseEventSeverity, setAdverseEventSeverity] = useState<IValueSet[]>([]);
    const [adverseEventOutcome, setAdverseEventOutcome] = useState<IValueSet[]>([]);
    const [adverseEventCausalityAssess, setAdverseEventCausalityAssess] = useState<IValueSet[]>([]);
    const [adverseEventCausalityMethod, setAdverseEventCausalityMethod] = useState<IValueSet[]>([]);

    const spacerMargin = '24px';

    useFhirAdverseEvents();
    useFhirAdverseEventBroadcast();
    const { practitionersList } = useFhirPractitioners();
    const { locationsList } = useFhirLocations();
    const { encountersList } = useFhirEncounters();
    const { conditionsList } = useFhirConditions();
    const { devicesList } = useFhirDevices();
    const { immunizationsList } = useFhirImmunizations();
    const { proceduresList } = useFhirProcedures();
    const { observationsList } = useFhirObservations();
    const { allergyIntolerancesList } = useFhirAllergyIntolerances();
    const { familyMemberHistoriesList } = useFhirFamilyMemberHistories();

    const contributorFieldArray = useFieldArray({ control, name: 'contributor' });
    const suspectEntityFieldArray = useFieldArray({ control, name: 'suspectEntity' });
    const subjectMedicalHistoryFieldArray = useFieldArray({ control, name: 'subjectMedicalHistory' });
    watch('suspectEntity');

    useEffect(() => {
        const loadValueSets = async () => {
            setLoading(true);
            try {
                const [
                    adverseEventActualityValueSet,
                    adverseEventCategoryValueSet,
                    adverseEventSeriousnessValueSet,
                    adverseEventSeverityValueSet,
                    adverseEventOutcomeValueSet,
                    adverseEventCausalityAssessValueSet,
                    adverseEventCausalityMethodValueSet
                ] = await Promise.all([
                    fetchValueSet(valueSetUrls.adverseEventActuality),
                    fetchValueSet(valueSetUrls.adverseEventCategory),
                    fetchValueSet(valueSetUrls.adverseEventSeriousness),
                    fetchValueSet(valueSetUrls.adverseEventSeverity),
                    fetchValueSet(valueSetUrls.adverseEventOutcome),
                    fetchValueSet(valueSetUrls.adverseEventCausalityAssess),
                    fetchValueSet(valueSetUrls.adverseEventCausalityMethod)
                ]);

                setAdverseEventActuality(adverseEventActualityValueSet);
                setAdverseEventCategory(adverseEventCategoryValueSet);
                setAdverseEventSeriousness(adverseEventSeriousnessValueSet);
                setAdverseEventSeverity(adverseEventSeverityValueSet);
                setAdverseEventOutcome(adverseEventOutcomeValueSet);
                setAdverseEventCausalityAssess(adverseEventCausalityAssessValueSet);
                setAdverseEventCausalityMethod(adverseEventCausalityMethodValueSet);
            } catch (err) {
                console.error('Error loading value sets:', err);
            } finally {
                setLoading(false);
            }
        };

        loadValueSets();
    }, [fetchValueSet, valueSetUrls]);

    const addSuspectEntity = () => {
        suspectEntityFieldArray.append({
            instance: null,
            causality: []
        });
    };

    const removeSuspectEntity = (index: number) => {
        suspectEntityFieldArray.remove(index);
    };

    const addCausality = (entityIndex: number) => {
        const path = `suspectEntity.${entityIndex}.causality`;
        const causality = getValues(path) || [];
        setValue(path, [...causality, {
            assessment: null,
            productRelatedness: '',
            author: null,
            method: null
        }]);
    };

    const removeCausality = (entityIndex: number, causalityIndex: number) => {
        const path = `suspectEntity.${entityIndex}.causality`;
        const causality = getValues(path) || [];
        causality.splice(causalityIndex, 1);
        setValue(path, causality);
    };

    return (
        <Card style={elevated ? { boxShadow: 'none' } : {}}>
            {elevated && <Elevation value={5}/>}
            <CardHeader>
                <Heading level={5}>Details</Heading>
            </CardHeader>
            <CardBody>
                {/* event */}
                <FhirValueSetSearch label="Type of the event itself in relation to the subject"
                                    context="event"
                                    valueSetUrl={valueSetUrls.adverseEventType}
                                    placeholder="Search for adverse events..."
                                    required={false}
                                    multiple={false}
                                    disabled={disabled}/>

                <Spacer margin={spacerMargin}/>

                {/* category */}
                <FhirCodeableConcept label="Category"
                                     context="category"
                                     options={adverseEventCategory}
                                     multiple={true}
                                     loading={loading}
                                     disabled={disabled}/>

                <Spacer margin={spacerMargin}/>

                {/* actuality */}
                <FhirCode label="Actuality"
                          context="actuality"
                          options={adverseEventActuality}
                          required={true}
                          loading={loading}
                          disabled={disabled}/>

                <Spacer margin={spacerMargin}/>

                {/* encounter */}
                {!isPatientRole && <>
                    <FhirReference label="Encounter created as part of"
                                   context="encounter"
                                   referenceType='Encounter'
                                   referenceList={encountersList}
                                   enableInlineActions={enableInlineActions}
                                   required={false}
                                   disabled={disabled}/>

                    <Spacer margin={spacerMargin}/>
                </>}

                {/* location */}
                <FhirReference label="Location where adverse event occurred"
                               context="location"
                               referenceType='Location'
                               referenceList={locationsList}
                               enableInlineActions={enableInlineActions}
                               required={false}
                               disabled={disabled}/>

                <Spacer margin={spacerMargin}/>

                {/* resultingCondition */}
                <FhirReference label="Effect on the subject due to this event"
                               context="resultingCondition"
                               referenceType="Condition"
                               referenceList={conditionsList}
                               enableInlineActions={enableInlineActions}
                               multiple={true}
                               required={false}
                               disabled={disabled}/>

                <Spacer margin={spacerMargin}/>
            </CardBody>
            <CardDivider/>
            <CardBody>
                <TabPanel initialTabName="details"
                          tabs={[
                              { name: 'details', title: 'Details' },
                              { name: 'entities', title: 'Suspect Entities' },
                              { name: 'contributors', title: 'Contributors' },
                              { name: 'medicalHistory', title: 'Medical History' }
                          ]}>
                    {(tab) => {
                        // details
                        if (tab.name === 'details') {
                            return (
                                <div style={{ paddingTop: '16px' }}>
                                    <Spacer margin={spacerMargin}/>

                                    {/* date */}
                                    <Controller key="date"
                                                name="date"
                                                control={control}
                                                disabled={disabled}
                                                render={({ field }) => (
                                                    <InputControl
                                                                  {...field}
                                                                  label="When the event occurred"
                                                                  type="datetime-local"/>
                                                )}/>

                                    <Spacer margin={spacerMargin}/>

                                    {/* detected */}
                                    <Controller key="detected"
                                                name="detected"
                                                control={control}
                                                disabled={disabled}
                                                render={({ field }) => (
                                                    <InputControl
                                                                  {...field}
                                                                  label="When the event was detected"
                                                                  type="datetime-local"/>
                                                )}/>

                                    <Spacer margin={spacerMargin}/>

                                    {/* recordedDate */}
                                    <Controller key="recordedDate"
                                                name="recordedDate"
                                                control={control}
                                                disabled={disabled}
                                                render={({ field }) => (
                                                    <InputControl
                                                                  {...field}
                                                                  label="When the event was recorded"
                                                                  type="datetime-local"/>
                                                )}/>

                                    <Spacer margin={spacerMargin}/>


                                    {/* seriousness */}
                                    <FhirCodeableConcept label="Seriousness of the event"
                                                         context="seriousness"
                                                         options={adverseEventSeriousness}
                                                         loading={loading}
                                                         disabled={disabled}
                                                         useShadcn/>

                                    <Spacer margin={spacerMargin}/>

                                    {/* severity */}
                                    <FhirCodeableConcept label="Severity"
                                                         context="severity"
                                                         options={adverseEventSeverity}
                                                         loading={loading}
                                                         disabled={disabled}
                                                         useShadcn/>

                                    <Spacer margin={spacerMargin}/>

                                    {/* outcome */}
                                    <FhirCodeableConcept label="Outcome"
                                                         context="outcome"
                                                         options={adverseEventOutcome}
                                                         loading={loading}
                                                         disabled={disabled}
                                                         useShadcn/>

                                    <Spacer margin={spacerMargin}/>
                                </div>
                            );
                        }

                        // entities
                        if (tab.name === 'entities') {
                            return (
                                <div style={{ paddingTop: '16px' }}>
                                    {suspectEntityFieldArray.fields.length === 0 && (
                                        <>
                                            <Flex>
                                                <FlexItem>
                                                    <button type="button"
                                                            className={`btn btn-blue-ghost${disabled ? ' btn-busy' : ''}`}
                                                            onClick={addSuspectEntity}
                                                            disabled={disabled}>
                                                        <PlusCircle className="w-4 h-4" />
                                                        Add Suspect Entity
                                                    </button>
                                                </FlexItem>
                                            </Flex>
                                            <Spacer margin="8"/>

                                            <DismissibleAlert status="info">
                                                No suspect entities added yet.
                                            </DismissibleAlert>

                                            <Spacer margin={spacerMargin}/>
                                        </>
                                    )}

                                    {suspectEntityFieldArray.fields.map((field, index) => (
                                        <React.Fragment key={field.id}>
                                            <Card>
                                                <CardHeader>
                                                    <Flex align="center" justify="space-between">
                                                        <FlexItem>
                                                            <h4>Suspect Entity {index + 1}</h4>
                                                        </FlexItem>
                                                        <FlexItem>
                                                            <button type="button"
                                                                    className="btn btn-red-ghost"
                                                                    title="Remove entity"
                                                                    aria-label="Remove entity"
                                                                    onClick={() => removeSuspectEntity(index)}
                                                                    disabled={disabled}>
                                                                <Trash2 className="w-4 h-4" />
                                                            </button>
                                                        </FlexItem>
                                                    </Flex>
                                                </CardHeader>
                                                <CardBody>
                                                    <Heading level={5}>Specific entity that caused the adverse event</Heading>
                                                    <Divider margin="2" />
                                                    <Spacer margin={spacerMargin}/>

                                                    <SuspectEntityInstanceReferences index={index}
                                                                                     disabled={disabled}
                                                                                     enableInlineActions={enableInlineActions}/>
                                                    <Spacer margin={spacerMargin}/>

                                                    <Heading level={5}>Information on the possible cause of the event</Heading>
                                                    <Divider margin="2" />
                                                    <Spacer margin={spacerMargin}/>

                                                    {(getValues(`suspectEntity.${index}.causality`) || []).length === 0 && (
                                                        <>
                                                            <Flex>
                                                                <FlexItem>
                                                                    <button type="button"
                                                                            className={`btn btn-blue-ghost${disabled ? ' btn-busy' : ''}`}
                                                                            onClick={() => addCausality(index)}
                                                                            disabled={disabled}>
                                                                        <PlusCircle className="w-4 h-4" />
                                                                        Add Causality Assessment
                                                                    </button>
                                                                </FlexItem>
                                                            </Flex>
                                                            <Spacer margin="8"/>

                                                            <DismissibleAlert status="info">
                                                                No causality assessments added yet.
                                                            </DismissibleAlert>

                                                            <Spacer margin={spacerMargin}/>
                                                        </>
                                                    )}

                                                    {(getValues(`suspectEntity.${index}.causality`) || []).map((_causality, causalityIndex) => (
                                                        <React.Fragment key={causalityIndex}>
                                                            <Card>
                                                                <CardHeader>
                                                                    <Flex align="center" justify="space-between">
                                                                        <FlexItem>
                                                                            <h4>Causality Assessment {causalityIndex + 1}</h4>
                                                                        </FlexItem>
                                                                        <FlexItem>
                                                                            <button type="button"
                                                                                    className="btn btn-red-ghost"
                                                                                    title="Remove assessment"
                                                                                    aria-label="Remove assessment"
                                                                                    onClick={() => removeCausality(index, causalityIndex)}
                                                                                    disabled={disabled}>
                                                                                <Trash2 className="w-4 h-4" />
                                                                            </button>
                                                                        </FlexItem>
                                                                    </Flex>
                                                                </CardHeader>
                                                                <CardBody>
                                                                    {/* assessment */}
                                                                    <FhirCodeableConcept label="Assessment of if the entity caused the event"
                                                                                         context={`suspectEntity.${index}.causality.${causalityIndex}.assessment`}
                                                                                         options={adverseEventCausalityAssess}
                                                                                         loading={loading}
                                                                                         disabled={disabled}/>

                                                                    <Spacer margin={spacerMargin}/>

                                                                    {/* productRelatedness */}
                                                                    <Controller key={`suspectEntity.${index}.causality.${causalityIndex}.productRelatedness`}
                                                                                name={`suspectEntity.${index}.causality.${causalityIndex}.productRelatedness`}
                                                                                control={control}
                                                                                disabled={disabled}
                                                                                render={({ field }) => (
                                                                                    <TextareaControl
                                                                                                     label="Product Relatedness"
                                                                                                     value={field.value}
                                                                                                     onChange={field.onChange}
                                                                                                     placeholder="Description of how the entity caused the event"
                                                                                                     rows={3}/>
                                                                                )}/>

                                                                    <Spacer margin={spacerMargin}/>

                                                                    {/* method */}
                                                                    <FhirCodeableConcept label="Method"
                                                                                         context={`suspectEntity.${index}.causality.${causalityIndex}.method`}
                                                                                         options={adverseEventCausalityMethod}
                                                                                         loading={loading}
                                                                                         disabled={disabled}/>

                                                                    <Spacer margin={spacerMargin}/>
                                                                </CardBody>
                                                            </Card>
                                                            <Spacer margin={spacerMargin}/>
                                                        </React.Fragment>
                                                    ))}

                                                    {(getValues(`suspectEntity.${index}.causality`) || []).length > 0 && (
                                                        <Flex justify="center">
                                                            <FlexItem>
                                                                <button type="button"
                                                                        className={`btn btn-blue-ghost${disabled ? ' btn-busy' : ''}`}
                                                                        onClick={() => addCausality(index)}
                                                                        disabled={disabled}>
                                                                    <PlusCircle className="w-4 h-4" />
                                                                    Add Causality Assessment
                                                                </button>
                                                            </FlexItem>
                                                        </Flex>
                                                    )}
                                                </CardBody>
                                            </Card>
                                            <Spacer margin={spacerMargin} />
                                        </React.Fragment>
                                    ))}

                                    {suspectEntityFieldArray.fields.length > 0 && (
                                        <Flex justify="center">
                                            <FlexItem>
                                                <button
                                                    type="button"
                                                    className={`btn btn-blue-ghost${disabled ? ' btn-busy' : ''}`}
                                                    onClick={addSuspectEntity}
                                                    disabled={disabled}
                                                >
                                                    <PlusCircle className="w-4 h-4" />
                                                    Add Suspect Entity
                                                </button>
                                            </FlexItem>
                                        </Flex>
                                    )}
                                </div>
                            );
                        }

                        // contributors
                        if (tab.name === 'contributors') {
                            return (
                                <div style={{ paddingTop: '16px' }}>
                                    {/* contributor */}
                                    <FhirReferenceCollection label="Who was involved in the adverse event or the potential adverse event"
                                                             references={contributorFieldArray}
                                                             context="contributor"
                                                             referenceTypes={[
                                                                 { name: 'Practitioner', key: 'Practitioner' },
                                                                 { name: 'Device', key: 'Device' }
                                                             ]}
                                                             getReferenceList={(referenceType: string): FhirResource[] => {
                                                                 switch (referenceType) {
                                                                     case 'Practitioner':
                                                                         return practitionersList.map(p => p.practitioner);
                                                                     case 'Device':
                                                                         return devicesList;
                                                                     default:
                                                                         return [];
                                                                 }
                                                             }}
                                                             required={false}
                                                             disabled={disabled}
                                                             multiple={true}
                                                             enableInlineActions={enableInlineActions}/>
                                </div>
                            );
                        }

                        // medicalHistory
                        if (tab.name === 'medicalHistory') {
                            return (
                                <div style={{ paddingTop: '16px' }}>
                                    {/* subjectMedicalHistory */}
                                    <FhirReferenceCollection label="Subject Medical History"
                                                             references={subjectMedicalHistoryFieldArray}
                                                             context="subjectMedicalHistory"
                                                             referenceTypes={[
                                                                 { name: 'Condition', key: 'Condition' },
                                                                 { name: 'Observation', key: 'Observation' },
                                                                 { name: 'AllergyIntolerance', key: 'AllergyIntolerance' },
                                                                 { name: 'FamilyMemberHistory', key: 'FamilyMemberHistory' },
                                                                 { name: 'Procedure', key: 'Procedure' }
                                                             ]}
                                                             getReferenceList={(referenceType: string): FhirResource[] => {
                                                                 switch (referenceType) {
                                                                     case 'Condition':
                                                                         return conditionsList;
                                                                     case 'Observation':
                                                                         return observationsList;
                                                                     case 'AllergyIntolerance':
                                                                         return allergyIntolerancesList;
                                                                     case 'FamilyMemberHistory':
                                                                         return familyMemberHistoriesList;
                                                                     case 'Immunization':
                                                                         return immunizationsList;
                                                                     case 'Procedure':
                                                                         return proceduresList;
                                                                     default:
                                                                         return [];
                                                                 }
                                                             }}
                                                             required={false}
                                                             disabled={disabled}
                                                             multiple={true}
                                                             enableInlineActions={enableInlineActions}/>
                                </div>
                            );
                        }
                    }}
                </TabPanel>
            </CardBody>
        </Card>
    );
};

export default FhirAdverseEvent;