import React from 'react';
import { Condition } from 'fhir/r4';
import { FhirCodeableConceptDisplay } from '../../utils/fhirCodeableConcept';
import { FhirIdentifierDisplay } from '../../utils/fhirIdentifier';
import { FhirReferenceDisplay } from '../../utils/fhirReference';
import { FhirAnnotationDisplay } from '../../utils/fhirAnnotation';
import { FhirAgeDisplay } from '../../utils/fhirAge';
import { FhirRangeDisplay } from '../../utils/fhirRange';
import { formatDateTime } from '../../utils/dateUtils';
import { FhirPeriodDisplay } from '../../utils/fhirPeriod';
import { renderField } from '../../utils/renderField';
import { conditionStatusText } from '../../utils/conditionStatus';
import { Dialog, DialogContent, DialogHeader, DialogTitle } from '../ui/dialog';
import { Card, CardHeader, CardContent } from '../ui/card';
import { FieldHistoryProvider, FieldHistoryScope } from '../FieldHistory/FieldHistoryProvider';
import { ShowFieldHistoryToggle } from '../FieldHistory/ShowFieldHistoryToggle';
import { RecordEditedMarker } from '../FieldHistory/RecordEditedMarker';
import type { ScopedSendRecovery } from '../../hooks/useScopedSendRecovery';
import { CorrectionRequestButton, CorrectionRequestComposer, useCorrectionRequest, type SendCorrectionRequest } from '../CorrectionRequest/CorrectionRequest';
import { FieldGroup, Section } from '../FieldHistory/FieldLayout';

interface FhirConditionDisplayProps {
    condition: Condition;
    isOpen: boolean;
    onClose: () => void;
    title?: string;
    /** Offered to a patient for a provider-authored record, which they can ask to correct but never edit. */
    onRequestCorrection?: SendCorrectionRequest;
    correctionError?: string;
    correctionRecovery?: ScopedSendRecovery;
}

export const FhirConditionDisplay: React.FC<FhirConditionDisplayProps> = ({
                                                                              condition,
                                                                              isOpen,
                                                                              onClose,
                                                                              title = "Condition Details",
                                                                              onRequestCorrection,
                                                                              correctionError,
                                                                              correctionRecovery,
                                                                          }) => {
    const renderOnsetDetails = () => {
        if (condition.onsetDateTime) {
            return formatDateTime(condition.onsetDateTime);
        }
        if (condition.onsetAge) {
            return <FhirAgeDisplay age={condition.onsetAge} />;
        }
        if (condition.onsetPeriod) {
            return <FhirPeriodDisplay period={condition.onsetPeriod} />;
        }
        if (condition.onsetRange) {
            return <FhirRangeDisplay range={condition.onsetRange} />;
        }
        if (condition.onsetString) {
            return condition.onsetString;
        }
        return '-';
    };

    const renderAbatementDetails = () => {
        if (condition.abatementDateTime) {
            return formatDateTime(condition.abatementDateTime);
        }
        if (condition.abatementAge) {
            return <FhirAgeDisplay age={condition.abatementAge} />;
        }
        if (condition.abatementPeriod) {
            return <FhirPeriodDisplay period={condition.abatementPeriod} />;
        }
        if (condition.abatementRange) {
            return <FhirRangeDisplay range={condition.abatementRange} />;
        }
        if (condition.abatementString) {
            return condition.abatementString;
        }
        if (condition.abatementBoolean === true) {
            return 'Yes';
        }
        if (condition.abatementBoolean === false) {
            return 'No';
        }
        return '-';
    };

    const renderStages = () => {
        if (!condition.stage || condition.stage.length === 0) {
            return (
                <p className="text-sm italic text-muted-foreground">
                    No stages recorded
                </p>
            );
        }

        return (
            <div className="flex flex-col gap-4">
                {condition.stage.map((stage, index) => (
                    <Card key={index}>
                        <CardHeader>
                            <h5 className="text-sm font-semibold">Stage {index + 1}</h5>
                        </CardHeader>
                        <CardContent>
                            <FieldGroup>
                                {renderField('Kind of staging', <FhirCodeableConceptDisplay code={stage.type} />)}
                                {renderField('Simple summary', <FhirCodeableConceptDisplay code={stage.summary} />)}
                                {renderField('Formal record of assessment', <FhirReferenceDisplay references={stage.assessment} />)}
                            </FieldGroup>
                        </CardContent>
                    </Card>
                ))}
            </div>
        );
    };

    const renderEvidence = () => {
        if (!condition.evidence || condition.evidence.length === 0) {
            return (
                <p className="text-sm italic text-muted-foreground">
                    No evidence recorded
                </p>
            );
        }

        return (
            <div className="flex flex-col gap-4">
                {condition.evidence.map((evidence, index) => (
                    <Card key={index}>
                        <CardHeader>
                            <h5 className="text-sm font-semibold">Evidence {index + 1}</h5>
                        </CardHeader>
                        <CardContent>
                            <FieldGroup>
                                {renderField('Manifestation/symptom', <FhirCodeableConceptDisplay code={evidence.code} multiple={true} />)}
                                {renderField('Supporting information', <FhirReferenceDisplay references={evidence.detail} />)}
                            </FieldGroup>
                        </CardContent>
                    </Card>
                ))}
            </div>
        );
    };

    const getConditionProfile = () => {
        if (condition.category && condition.category.length > 0) {
            const category = condition.category[0];
            if (category.coding && category.coding.length > 0) {
                const code = category.coding[0].code;
                if (code === 'encounter-diagnosis') {
                    return 'Encounter Diagnosis';
                }
                if (code === 'problem-list-item' || code === 'health-concern') {
                    return 'Problems and Health Concerns';
                }
            }
        }
        return '';
    };

    // `condition` is frequently a forced cast over a union of resource types (several callers keep
    // one `selectedItem`/`selected.resource` and multiplex it across many `Fhir*Display` modals,
    // gating only via `isOpen`) -- it can be the wrong resource shape, or undefined, whenever
    // `isOpen` is false. This guard must run before anything below touches `condition.*` so a
    // non-Condition/absent value while closed never throws (mirrors the original `if (!isOpen)
    // return null;` that ran before WP's `<Modal>` was ever constructed).
    const correction = useCorrectionRequest(condition?.id);
    if (!isOpen) return null;

    return (
        <Dialog
            open={isOpen}
            onOpenChange={(next) => {
                if (!next) onClose();
            }}
        >
            <DialogContent className="max-h-[90vh] w-full max-w-3xl overflow-y-auto">
                <FieldHistoryProvider>
                    <FieldHistoryScope resourceType="Condition" id={condition.id}>
                        <DialogHeader className="flex-row items-center justify-between gap-4 text-left sm:text-left">
                            <div className="flex items-center gap-2">
                                <DialogTitle>{title}</DialogTitle>
                                <RecordEditedMarker resource={condition} />
                            </div>
                            <ShowFieldHistoryToggle />
                            {onRequestCorrection && <CorrectionRequestButton request={correction} />}
                        </DialogHeader>

                        {onRequestCorrection && (
                            <CorrectionRequestComposer request={correction} onSend={onRequestCorrection} error={correctionError} idPrefix="condition" earlier={correctionRecovery} />
                        )}

                        <Card>
                            <CardHeader>
                                <h4 className="text-lg font-semibold">
                                    {condition?.code?.text || condition?.code?.coding?.[0]?.display || 'Condition'}
                                </h4>
                                <p className="text-sm text-muted-foreground">
                                    {getConditionProfile() ? `${condition?.resourceType} - ${getConditionProfile()}` : condition?.resourceType}
                                </p>
                            </CardHeader>
                        </Card>

                        <FieldGroup>
                            {renderField('Identification of the condition, problem or diagnosis', <FhirCodeableConceptDisplay code={condition.code} />, 'code.coding[0].display')}
                            {renderField('Category', <FhirCodeableConceptDisplay code={condition.category} multiple={true} />)}
                            {renderField('Subjective severity of condition', <FhirCodeableConceptDisplay code={condition.severity} />, 'severity.coding[0].display')}
                            {renderField('Clinical Status', <span>{conditionStatusText(condition.clinicalStatus, 'clinical')}</span>, 'clinicalStatus.coding[0].code')}
                            {renderField('Verification Status', <span>{conditionStatusText(condition.verificationStatus, 'verification')}</span>, 'verificationStatus.coding[0].code')}
                            {renderField('Anatomical location, if relevant', <FhirCodeableConceptDisplay code={condition.bodySite} multiple={true} />)}
                            {renderField('Subject', <FhirReferenceDisplay references={condition.subject} />)}
                            {renderField('Encounter created as part of', <FhirReferenceDisplay references={condition.encounter} />)}
                            {renderField('Date record was first recorded', formatDateTime(condition.recordedDate), 'recordedDate')}
                            {renderField('Identifiers', <FhirIdentifierDisplay identifier={condition.identifier} />)}
                        </FieldGroup>

                        <Section title="When did the condition begin?">
                            <FieldGroup>
                                {renderField('Estimated or actual date, date-time, or age', renderOnsetDetails())}
                            </FieldGroup>
                        </Section>

                        <Section title="When did the condition resolve?">
                            <FieldGroup>
                                {renderField('When in resolution/remission', renderAbatementDetails())}
                            </FieldGroup>
                        </Section>

                        <Section title="Stages">
                            {renderStages()}
                        </Section>

                        <Section title="Evidence">
                            {renderEvidence()}
                        </Section>

                        <Section title="Notes">
                            <FieldGroup>
                                {renderField('Additional information about the Condition', <FhirAnnotationDisplay annotation={condition.note} multiple={true} />)}
                            </FieldGroup>
                        </Section>
                    </FieldHistoryScope>
                </FieldHistoryProvider>
            </DialogContent>
        </Dialog>
    );
};

export default FhirConditionDisplay;