import { useContext, useRef, useState } from "react";
import Button from "@moduletrace/twui/layout/Button";
import Row from "@moduletrace/twui/layout/Row";
import Span from "@moduletrace/twui/layout/Span";
import Stack from "@moduletrace/twui/layout/Stack";
import Textarea from "@moduletrace/twui/form/Textarea";
import { OpenTaskStatuses } from "@/src/dict/task-dict";
import type { TaskDetail, TaskFile } from "@/src/types";
import TaskFileRow from "@/src/components/general/task-file-row";
import HandOverForm from "@/src/components/general/hand-over-form";
import TaskForm from "@/src/components/general/task-form";
import TaskStatusChip from "@/src/components/general/task-status-chip";
import TaskStatusMoves from "@/src/components/general/task-status-moves";
import BotAvatar from "@/src/components/general/bot-avatar";
import TaskFactRow from "@/src/components/general/task-fact-row";
import TaskNoteRow from "@/src/components/general/task-note-row";
import type { BotFace } from "@/src/dict/bot-dict";
import { AppContext } from "@/src/pages/__root";
import botStoneProps from "@/src/utils/bot-stone-props";
import relativeTime from "@/src/utils/relative-time";
import fetchApi from "@moduletrace/twui/utils/fetch/fetchApi";
import type { APIResponseObject } from "@moduletrace/bunext/types";

type Props = {
    task: TaskDetail;
    /**
     * A crew manager can change it, file onto it and delete it.
     */
    can_manage?: boolean;
    onChanged: (task: TaskDetail, msg?: string) => void;
    onDeleted: () => void;
};

/**
 * One task opened: its status (a crew manager moves it along), who has it and where, who added it and
 * when it last moved, what it is, its files (each opening its bytes), its
 * notes oldest first, a box to add a note, and edit or delete. A crew
 * manager can file a new deliverable straight onto it, or hand an open
 * one to another bot, which starts on it.
 */
export default function TaskDetailPanel({ task, can_manage, onChanged, onDeleted }: Props) {
    const { pageProps } = useContext(AppContext);
    const [editing, setEditing] = useState(false);
    const [handing_over, setHandingOver] = useState(false);
    const [note, setNote] = useState("");
    const [busy, setBusy] = useState(false);
    const [status, setStatus] = useState<string>();
    const file_input = useRef<HTMLInputElement>(null);

    const run = async (params: { path: string; body: Record<string, unknown>; done: string }) => {
        if (busy) return;

        setBusy(true);
        setStatus(undefined);

        const res = await fetchApi<Record<string, unknown>, APIResponseObject<TaskDetail>>(
            `/api/admin/${params.path}`,
            { method: "POST", body: params.body },
        );

        setBusy(false);

        if (!res.success || !res.singleRes) {
            setStatus(res.msg || "That didn't work.");
            return;
        }

        setStatus(params.done);
        onChanged(res.singleRes, params.done);
    };

    const addNote = async () => {
        if (!note.trim()) return;

        await run({ path: "tasks/add-note", body: { task_id: Number(task.id), text: note }, done: "Note added." });
        setNote("");
    };

    const attach = async (file: File) => {
        if (busy) return;

        const data_url = await new Promise<string>((resolve, reject) => {
            const reader = new FileReader();
            reader.onload = () => resolve(String(reader.result || ""));
            reader.onerror = () => reject(reader.error);
            reader.readAsDataURL(file);
        }).catch(() => "");

        if (!data_url) {
            setStatus(`${file.name} couldn't be read.`);
            return;
        }

        await run({
            path: "tasks/attach-file",
            body: { task_id: Number(task.id), data_url, name: file.name, kind: "deliverable" },
            done: `${file.name} added as a deliverable.`,
        });
    };

    const detach = async ({ file }: { file: TaskFile }) => {
        if (!window.confirm(`Unlink ${file.name || "this file"} from the task?`)) return;

        await run({
            path: "tasks/detach-file",
            body: { task_id: Number(task.id), task_media_id: Number(file.id) },
            done: "File unlinked.",
        });
    };

    if (editing) {
        return (
            <TaskForm
                task={task}
                onCancel={() => setEditing(false)}
                onSaved={(saved, msg) => {
                    setEditing(false);
                    onChanged(saved, msg);
                }}
            />
        );
    }

    if (handing_over) {
        return (
            <HandOverForm<TaskDetail>
                what={`"${task.title}"`}
                targets_path="tasks/hand-over-targets"
                submit_path="tasks/hand-over-task"
                body={{ task_id: Number(task.id) }}
                with_note
                onCancel={() => setHandingOver(false)}
                onHandedOver={({ saved, msg }) => {
                    setHandingOver(false);
                    onChanged(saved, msg);
                }}
            />
        );
    }

    const deliverables = task.files.filter((file) => file.kind != "reference");
    const references = task.files.filter((file) => file.kind == "reference");

    return (
        <Stack className="w-full gap-4! items-stretch">
            <Row className="w-full gap-2! flex-nowrap items-center">
                <TaskStatusChip status={task.status} />
                {can_manage ? (
                    <TaskStatusMoves
                        status={task.status}
                        disabled={busy}
                        onMove={(next) =>
                            run({
                                path: "tasks/save-task",
                                body: { task_id: Number(task.id), status: next },
                                done: "Status changed.",
                            })
                        }
                    />
                ) : null}
                {can_manage ? (
                    <Row className="ml-auto shrink-0 gap-1! flex-nowrap">
                        {(OpenTaskStatuses as readonly string[]).includes(task.status || "") ? (
                            <Button
                                title="Hand the task to another bot"
                                type="button"
                                variant="ghost"
                                color="gray"
                                size="small"
                                disabled={busy}
                                onClick={() => setHandingOver(true)}
                                className="px-2! text-[12px]"
                            >
                                Hand over
                            </Button>
                        ) : null}
                        <Button
                            title="Edit the task"
                            type="button"
                            variant="ghost"
                            color="gray"
                            size="small"
                            disabled={busy}
                            onClick={() => setEditing(true)}
                            className="px-2! text-[12px]"
                        >
                            Edit
                        </Button>
                        <Button
                            title="Delete the task"
                            type="button"
                            variant="ghost"
                            color="gray"
                            size="small"
                            disabled={busy}
                            onClick={async () => {
                                if (!window.confirm(`Delete "${task.title}"? Its notes and links go with it.`)) return;

                                setBusy(true);
                                const res = await fetchApi<Record<string, unknown>, APIResponseObject>(
                                    "/api/admin/tasks/delete-task",
                                    { method: "POST", body: { task_id: Number(task.id) } },
                                );
                                setBusy(false);

                                if (!res.success) {
                                    setStatus(res.msg || "That didn't work.");
                                    return;
                                }

                                onDeleted();
                            }}
                            className="px-2! text-[12px]"
                        >
                            Delete
                        </Button>
                    </Row>
                ) : null}
            </Row>

            <Stack className="w-full gap-1.5! items-stretch">
                <TaskFactRow label="Who has it">
                    {task.bot_id ? (
                        <>
                            <BotAvatar
                                image_media_id={task.bot_image_media_id}
                                {...botStoneProps({ color: task.bot_color, stone: task.bot_stone, hue: task.bot_hue })}
                                face={(task.bot_face || "idle") as BotFace}
                                size={18}
                            />
                            <Span className="min-w-0 truncate">{task.bot_name || `Bot ${task.bot_id}`}</Span>
                        </>
                    ) : (
                        <Span className="text-ink-secondary">No bot</Span>
                    )}
                </TaskFactRow>
                <TaskFactRow label="Where">
                    <Span className="min-w-0 truncate">
                        {task.workspace_id
                            ? task.workspace_name || `Workspace ${task.workspace_id}`
                            : `${task.bot_name || "The bot"}'s own list`}
                    </Span>
                </TaskFactRow>
                <TaskFactRow label="Added">
                    <Span className="min-w-0 truncate">
                        {[
                            task.created_by_bot_id
                                ? `By ${task.created_by_bot_name || `bot ${task.created_by_bot_id}`}`
                                : task.created_by_user_id
                                  ? task.created_by_user_id == pageProps?.user?.id
                                      ? "By you"
                                      : `By ${task.created_by_user_name || "a user"}`
                                  : task.origin == "bot"
                                    ? "By a bot"
                                    : "By hand",
                            task.created_at ? relativeTime({ at: Number(task.created_at) }) : null,
                        ]
                            .filter(Boolean)
                            .join(" · ")}
                    </Span>
                </TaskFactRow>
                {task.updated_at ? (
                    <TaskFactRow label="Last moved">
                        <Span>{relativeTime({ at: Number(task.updated_at) })}</Span>
                    </TaskFactRow>
                ) : null}
                {task.completed_at ? (
                    <TaskFactRow label="Finished">
                        <Span>{relativeTime({ at: Number(task.completed_at) })}</Span>
                    </TaskFactRow>
                ) : null}
            </Stack>

            {task.status == "blocked" && task.blocked_reason ? (
                <Span className="text-[13px] leading-[18px] text-ink">{`Waiting on you: ${task.blocked_reason}`}</Span>
            ) : null}

            {task.description ? (
                <Span className="whitespace-pre-wrap text-[13px] leading-[19px] text-ink">{task.description}</Span>
            ) : null}

            <Stack className="w-full gap-1! items-stretch">
                <Span className="text-[12px] font-bold leading-4 text-ink-secondary">
                    {task.files.length ? `Files (${task.files.length})` : "Files"}
                </Span>
                {deliverables.length || references.length ? (
                    <Stack className="w-full gap-0! items-stretch">
                        {[...deliverables, ...references].map((file) => (
                            <TaskFileRow
                                key={file.id}
                                file={file}
                                busy={busy}
                                onDetach={can_manage ? () => detach({ file }) : undefined}
                            />
                        ))}
                    </Stack>
                ) : (
                    <Span className="text-[13px] leading-[18px] text-ink-secondary">Nothing filed yet.</Span>
                )}
                {can_manage ? (
                    <Row className="gap-2! flex-nowrap items-center">
                        <input
                            ref={file_input}
                            type="file"
                            className="hidden"
                            onChange={(event) => {
                                const file = event.target.files?.[0];
                                if (file) attach(file).catch(() => {});
                                event.target.value = "";
                            }}
                        />
                        <Button
                            title="Add a file as a deliverable"
                            type="button"
                            variant="ghost"
                            color="gray"
                            size="small"
                            disabled={busy}
                            onClick={() => file_input.current?.click()}
                            className="px-2! text-[12px]"
                        >
                            Add a file
                        </Button>
                    </Row>
                ) : null}
            </Stack>

            <Stack className="w-full gap-1! items-stretch">
                <Span className="text-[12px] font-bold leading-4 text-ink-secondary">
                    {task.notes.length ? `Notes (${task.notes.length})` : "Notes"}
                </Span>
                {task.notes.length ? (
                    <Stack className="w-full gap-0! items-stretch">
                        {task.notes.map((entry) => (
                            <TaskNoteRow key={entry.id} note={entry} />
                        ))}
                    </Stack>
                ) : (
                    <Span className="text-[13px] leading-[18px] text-ink-secondary">No notes yet.</Span>
                )}
                <Textarea
                    placeholder="Add a note"
                    value={note}
                    changeHandler={setNote}
                    rows={2}
                    disabled={busy}
                />
                <Row className="justify-end">
                    <Button
                        title="Add the note"
                        type="button"
                        variant="outlined"
                        color="gray"
                        size="small"
                        loading={busy}
                        disabled={busy || !note.trim()}
                        onClick={() => addNote().catch(() => {})}
                    >
                        Add note
                    </Button>
                </Row>
            </Stack>

            {status ? (
                <Span role="status" className="text-[13px] leading-[18px] text-ink-secondary">
                    {status}
                </Span>
            ) : null}
        </Stack>
    );
}