import { useState } from "react";
import {
    AlertCircle, Building2, FileInput, KeyRound, ListChecks, Loader2, Pencil, Plus, Power, PowerOff, SlidersHorizontal,
} from "lucide-react";
import { Button } from "../../../../components/ui/button.tsx";
import { Badge } from "../../../../components/ui/badge.tsx";
import { Alert, AlertDescription } from "../../../../components/ui/alert.tsx";
import { EmptyState } from "../../../../components/ui/empty-state.tsx";
import {
    AKASHIC_LAB_CONNECTION,
    LAB_CONNECTION_TYPES,
    useLabConnections,
    type LabConnection,
} from "../../../../hooks/useLabConnections.ts";
import LabConnectionEditor, { type ConnectionTarget } from "./LabConnectionEditor.tsx";
import LabProfileEditor, { type ProfileTarget } from "./LabProfileEditor.tsx";
import LabCredentialsDialog, { type CredentialsTarget } from "./LabCredentialsDialog.tsx";
import LabTestCodesDialog, { type TestCodesTarget } from "./LabTestCodesDialog.tsx";
import LabResultReturnDialog, { type ResultReturnTarget } from "./LabResultReturnDialog.tsx";
import { returnWords } from "./labResultReturnWords.ts";
import "./DiagnosticsPage.css";

// The laboratories this practice sends to.
//
// ITS OWN TAB BECAUSE IT IS ITS OWN QUESTION. The catalogue beside it answers "what can this practice
// order"; this answers "where does an order go", and the two change for different reasons and are
// edited by different people on different days.
//
// A LABORATORY IS SWITCHED OFF RATHER THAN DELETED, so there is no delete here and none on the
// server. A practice that has stopped using one keeps its account number and the history of what was
// sent through it -- and the account number is exactly what they need when that laboratory rings
// about work sent last year. A switched-off one stays on the list, greyed and marked.
//
// Each laboratory says where its orders go, from the server's own answer: electronically, or on paper and why.

const transportLabel = (connection: LabConnection) =>
    LAB_CONNECTION_TYPES.find((each) => each.id === connection.connectionType)?.label;

/** What the server does with this laboratory's orders. A laboratory on Akashic is reached in-network and needs no line. */
const sendWords = (connection: LabConnection): string | undefined => {
    const transport = LAB_CONNECTION_TYPES.find((each) => each.id === connection.connectionType);
    if (!transport || transport.id === AKASHIC_LAB_CONNECTION) return undefined;
    if (!transport.sends) return `Orders go on paper: Akashic does not send over ${transport.label} yet.`;
    if (connection.electronic) return "Orders for paired tests go to it electronically.";
    if (connection.active === false) return "Orders go on paper while it is switched off.";
    if (!connection.address?.trim()) return "Orders go on paper until it has an address.";
    // No decision in the answer is unknown, never paper.
    if (connection.electronic === undefined || connection.credentialsConfigured === undefined) {
        return "Whether its orders go electronically could not be read just now.";
    }
    if (!connection.credentialsConfigured) return "Orders go on paper until a sign-in is saved.";
    return "Orders go on paper.";
};

const reviewedCount = (connection: LabConnection) =>
    (connection.testMappings ?? []).filter((each) => each.reviewedAt).length;

const LabConnections = () => {
    const {
        connections, loading, error, accountsUnreadable, reload, addConnection, saveConnection, saveProfile, saveTestMappings, setActive,
        saveCredentials, removeCredentials, saveAccountParameter, checkResultReturn, readResults,
    } = useLabConnections();
    const [returning, setReturning] = useState<ResultReturnTarget>();

    const [target, setTarget] = useState<ConnectionTarget>();
    const [describing, setDescribing] = useState<ProfileTarget>();
    const [signingIn, setSigningIn] = useState<CredentialsTarget>();
    const [pairing, setPairing] = useState<TestCodesTarget>();
    const [switching, setSwitching] = useState<string>();
    const [switchFailure, setSwitchFailure] = useState<string>();

    const toggle = async (connection: LabConnection) => {
        setSwitching(connection.id);
        setSwitchFailure(undefined);
        try {
            await setActive(connection.id as string, connection.active === false);
        } catch (failure) {
            console.error("Error switching a laboratory connection:", failure);
            setSwitchFailure("That laboratory could not be changed. Please try again.");
        } finally {
            setSwitching(undefined);
        }
    };

    if (loading) {
        return (
            <p className="diagnostics-note diagnostics-loading">
                <Loader2 className="h-4 w-4 animate-spin" />
                Loading the laboratories…
            </p>
        );
    }

    return (
        <div className="diagnostics-catalogue">
            {error ? (
                <Alert variant="destructive">
                    <AlertCircle className="h-4 w-4" />
                    <AlertDescription>{error}</AlertDescription>
                    <Button className="btn btn-blue-ghost diagnostics-retry" onClick={() => void reload()}>
                        Try again
                    </Button>
                </Alert>
            ) : null}
            {switchFailure ? (
                <Alert variant="destructive">
                    <AlertCircle className="h-4 w-4" />
                    <AlertDescription>{switchFailure}</AlertDescription>
                </Alert>
            ) : null}

            <section className="ak-card ak-card--panel diagnostics-panel">
                <h2 className="ak-section-title">External laboratories</h2>
                <p className="ak-body">
                    Your practice keeps its own laboratory accounts. Connection settings do not prove delivery.
                </p>

                {accountsUnreadable ? (
                    <p className="diagnostics-note" role="alert">
                        Account numbers and sign-ins could not be read just now, so they are not shown.
                    </p>
                ) : null}

                {error && connections.length === 0 ? null : connections.length === 0 ? (
                    <EmptyState
                        icon={Building2}
                        title="No laboratories yet"
                        description="Record your external laboratories so requisitions include the right account number."
                        size="compact"
                    />
                ) : (
                    <ul className="diagnostics-list">
                        {connections.map((connection) => (
                            <li
                                className={
                                    connection.active === false
                                        ? "diagnostics-row diagnostics-row--stacked diagnostics-row-off"
                                        : "diagnostics-row diagnostics-row--stacked"
                                }
                                key={connection.id}
                            >
                                <div className="diagnostics-row-lead">
                                    <span className="diagnostics-name">
                                        {connection.name ?? "Unnamed laboratory"}
                                    </span>
                                    {transportLabel(connection) ? (
                                        <Badge variant="outline">{transportLabel(connection)}</Badge>
                                    ) : null}
                                    {connection.active === false ? <Badge variant="outline">Off</Badge> : null}
                                </div>
                                <p className="diagnostics-row-detail">
                                    {[
                                        // An Akashic link's address is the practice's record id, not somewhere a person sends to.
                                        connection.connectionType === AKASHIC_LAB_CONNECTION ? undefined : connection.address,
                                        connection.npi ? `NPI ${connection.npi}` : undefined,
                                        connection.accountNumber
                                            ? `Account ${connection.accountNumber}`
                                            : undefined,
                                    ].filter(Boolean).join(" · ")}
                                </p>
                                {sendWords(connection) ? (
                                    <p className="diagnostics-row-detail">{sendWords(connection)}</p>
                                ) : null}
                                {returnWords(connection) ? (
                                    <p className="diagnostics-row-detail">{returnWords(connection)}</p>
                                ) : null}
                                <div className="diagnostics-row-actions">
                                    <Button
                                        className="btn btn-blue-ghost"
                                        onClick={() => setTarget({ mode: "edit", connection })}
                                    >
                                        <Pencil className="h-4 w-4" />
                                        Edit
                                    </Button>
                                    {/* How the laboratory wants an order said. The count is the useful
                                        thing at a glance: a connection with no profile cannot be sent
                                        to however correct its address is. */}
                                    <Button
                                        className="btn btn-blue-ghost"
                                        onClick={() => setDescribing({ connection })}
                                    >
                                        <SlidersHorizontal className="h-4 w-4" />
                                        {connection.profile?.fields?.length
                                            ? `Order format · ${connection.profile.fields.length} fields`
                                            : "Describe the order format"}
                                    </Button>
                                    <Button
                                        className="btn btn-blue-ghost"
                                        onClick={() => setPairing({ connection })}
                                    >
                                        <ListChecks className="h-4 w-4" />
                                        {reviewedCount(connection)
                                            ? "Test codes: " + reviewedCount(connection) + " reviewed"
                                            : "Pair test codes"}
                                    </Button>
                                    <Button
                                        className="btn btn-blue-ghost"
                                        onClick={() => setSigningIn({ connection })}
                                    >
                                        <KeyRound className="h-4 w-4" />
                                        {connection.credentialsConfigured === undefined
                                            ? "Sign-in not checked"
                                            : connection.credentialsConfigured ? "Sign-in saved" : "Add a sign-in"}
                                    </Button>
                                    {returnWords(connection) ? (
                                        <Button
                                            className="btn btn-blue-ghost"
                                            onClick={() => setReturning({ connection })}
                                        >
                                            <FileInput className="h-4 w-4" />
                                            Results
                                        </Button>
                                    ) : null}
                                    <Button
                                        className="btn btn-blue-ghost"
                                        disabled={switching === connection.id}
                                        onClick={() => void toggle(connection)}
                                    >
                                        {connection.active === false ? (
                                            <Power className="h-4 w-4" />
                                        ) : (
                                            <PowerOff className="h-4 w-4" />
                                        )}
                                        {connection.active === false ? "Switch on" : "Switch off"}
                                    </Button>
                                </div>
                            </li>
                        ))}
                    </ul>
                )}

                <p className="diagnostics-note">
                    Recording a laboratory prints its account number on the requisition. Each one above says
                    whether its orders go electronically or on paper.
                </p>
                <div className="diagnostics-setup__footer">
                    <Button className="btn btn-blue-ghost" onClick={() => setTarget({ mode: "add" })}>
                        <Plus className="h-4 w-4" />
                        Add a laboratory
                    </Button>
                </div>
            </section>

            <LabConnectionEditor
                target={target}
                onClose={() => setTarget(undefined)}
                addConnection={addConnection}
                saveConnection={saveConnection}
            />

            <LabProfileEditor
                target={describing}
                onClose={() => setDescribing(undefined)}
                saveProfile={saveProfile}
            />

            <LabTestCodesDialog
                target={pairing}
                onClose={() => setPairing(undefined)}
                saveTestMappings={saveTestMappings}
            />

            <LabCredentialsDialog
                target={signingIn}
                onClose={() => setSigningIn(undefined)}
                saveCredentials={saveCredentials}
                removeCredentials={removeCredentials}
            />

            <LabResultReturnDialog
                target={returning}
                connections={connections}
                onClose={() => setReturning(undefined)}
                saveAccountParameter={saveAccountParameter}
                checkResultReturn={checkResultReturn}
                readResults={readResults}
                reload={reload}
            />
        </div>
    );
};

export default LabConnections;