/* @odoo-module */

import { startServer } from "@bus/../tests/helpers/mock_python_environment";
import { getFixture } from "@web/../tests/helpers/utils";
import { makeView, setupViewRegistries } from "@web/../tests/views/helpers";
import { start } from "@mail/../tests/helpers/test_utils";
import { checkLabels, checkLegend, selectMode } from "@web/../tests/views/graph_view_tests";
import {
    patchDialog,
    getColumn,
    toggleColumnActions,
    createColumn,
} from "@web/../tests/views/kanban/helpers";

let target;
let serverData;

QUnit.module("helpdesk", (hooks) => {
    hooks.beforeEach(async () => {
        const pyEnv = await startServer();
        pyEnv.mockServer.models["helpdesk.stage"] = {
            fields: {
                id: { string: "ID", type: "integer" },
                display_name: { string: "Name", type: "char" },
            },
            records: [
                { id: 1, display_name: "Stage 1" },
                { id: 2, display_name: "Stage 2" },
                { id: 3, display_name: "Stage 3" },
            ],
        };
        pyEnv.mockServer.models["helpdesk.team"] = {
            fields: {
                id: { string: "ID", type: "integer" },
                display_name: { string: "Name", type: "char" },
            },
            records: [
                { id: 1, display_name: "Team 1" },
                { id: 2, display_name: "Team 2", stage_ids: false },
            ],
        };
        pyEnv.mockServer.models["helpdesk.ticket"] = {
            fields: {
                id: { string: "Id", type: "integer" },
                name: { string: "Name", type: "char" },
                sla_deadline: {
                    string: "SLA Deadline",
                    type: "date",
                    store: true,
                    sortable: true,
                },
                team_id: { string: "Team", type: "many2one", relation: "helpdesk.team" },
                stage_id: { string: "Stage", type: "many2one", relation: "helpdesk.stage" },
            },
            records: [
                { id: 1, name: "My ticket", sla_deadline: false, team_id: 1, stage_id: 1 },
                { id: 2, name: "Ticket 2", team_id: 1, stage_id: 1 },
                { id: 3, name: "Ticket 3", team_id: 1, stage_id: 2 },
            ],
        };
        serverData = {
            views: {
                "helpdesk.ticket,false,kanban": `
                    <kanban default_group_by="stage_id" js_class="helpdesk_ticket_kanban">
                        <field name="stage_id"/>
                        <templates>
                            <t t-name="kanban-box">
                                <div>
                                    <field name="name"/>
                                    <field name="sla_deadline"/>
                                </div>
                            </t>
                        </templates>
                    </kanban>
                `,
                "helpdesk.ticket,1,kanban": `<kanban js_class="helpdesk_ticket_kanban" default_group_by="sla_deadline">
                        <templates>
                            <t t-name="kanban-box"/>
                        </templates>
                    </kanban>`,
                "helpdesk.ticket,false,graph": `<graph/>`,
                "helpdesk.ticket,false,search": `<search/>`,
            },
        };
        target = getFixture();
        setupViewRegistries();
    });

    QUnit.module("helpdesk_ticket_list");

    QUnit.test("Test group label for empty SLA Deadline in tree", async function (assert) {
        const views = {
            "helpdesk.ticket,false,list": `<tree js_class="helpdesk_ticket_list">
                    <field name="sla_deadline" widget="remaining_days"/>
                </tree>`,
            "helpdesk.ticket,false,search": `<search/>`,
        };
        const { openView } = await start({
            serverData: { views },
        });
        await openView({
            res_model: "helpdesk.ticket",
            views: [[false, "tree"]],
            context: { group_by: ["sla_deadline"] },
        });

        assert.strictEqual(target.querySelector(".o_group_name").innerText, "Deadline reached (3)");
    });

    QUnit.module("helpdesk_ticket_kanban");

    QUnit.test("Test group label for empty SLA Deadline in kanban", async function (assert) {
        const { openView } = await start({
            serverData,
        });
        await openView({
            res_model: "helpdesk.ticket",
            views: [[1, "kanban"]],
        });

        assert.strictEqual(target.querySelector(".o_column_title").innerText, "Deadline reached");
    });

    QUnit.test("delete a column in grouped on m2o", async function (assert) {
        let dialogProps;

        patchDialog((_cls, props) => {
            assert.ok(true, "a confirm modal should be displayed");
            dialogProps = props;
        });

        const { openView } = await start({
            serverData,
            async mockRPC(route, { ids, method, model }) {
                if (model === "helpdesk.stage" && method === "action_unlink_wizard") {
                    assert.step(`${model}/${method}`);
                    return {
                        type: "ir.actions.client",
                        tag: "reload",
                    };
                }
            },
        });
        await openView({
            res_model: "helpdesk.ticket",
            views: [[false, "kanban"]],
        });

        assert.containsN(target, ".o_kanban_group", 2, "should have 2 columns");
        assert.strictEqual(
            getColumn(target, 0).querySelector(".o_column_title").innerText,
            "Stage 1"
        );
        assert.strictEqual(
            getColumn(target, 1).querySelector(".o_column_title").innerText,
            "Stage 2"
        );
        assert.containsN(getColumn(target, 0), ".o_kanban_record", 2);
        assert.containsN(getColumn(target, 1), ".o_kanban_record", 1);

        const clickColumnAction = await toggleColumnActions(target, 1);
        await clickColumnAction("Delete");
        assert.strictEqual(dialogProps, undefined, "No dialog should be displayed");
        assert.verifySteps(["helpdesk.stage/action_unlink_wizard"]);
    });

    QUnit.test(
        "Cannot create group if we are not in tickets of specific helpdesk team",
        async function (assert) {
            const { openView } = await start({
                serverData,
            });
            await openView({
                res_model: "helpdesk.ticket",
                views: [[false, "kanban"]],
            });

            assert.containsN(target, ".o_kanban_group", 2);
            assert.containsNone(
                target,
                ".o_column_quick_create",
                "should have no quick create column"
            );
        }
    );

    QUnit.test("Can create group if we are a specific helpdesk team", async function (assert) {
        const { openView } = await start({
            serverData,
        });
        await openView({
            res_model: "helpdesk.ticket",
            views: [[false, "kanban"]],
            context: {
                active_model: "helpdesk.team",
                default_team_id: 1,
                active_id: 1,
            },
        });

        assert.containsN(target, ".o_kanban_group", 2);
        assert.containsOnce(target, ".o_column_quick_create", "should have no quick create column");
        assert.containsNone(
            target,
            ".o_column_quick_create input",
            "the input should not be visible"
        );

        await createColumn(target);

        assert.containsOnce(target, ".o_column_quick_create input", "the input should be visible");
    });
    QUnit.module("helpdesk_ticket_pivot");

    QUnit.test("Test group label for empty SLA Deadline in pivot", async function (assert) {
        const views = {
            "helpdesk.ticket,false,pivot": `<pivot js_class="helpdesk_ticket_pivot">
                    <field name="sla_deadline" type="row"/>
                </pivot>`,
            "helpdesk.ticket,false,search": `<search/>`,
        };
        const { openView } = await start({
            serverData: { views },
        });
        await openView({
            res_model: "helpdesk.ticket",
            views: [[false, "pivot"]],
        });

        assert.strictEqual(
            target.querySelector("tr:nth-of-type(2) .o_pivot_header_cell_closed").innerText,
            "Deadline reached"
        );
    });

    QUnit.module("helpdesk_ticket_graph");

    QUnit.test("Test group label for empty SLA Deadline in graph", async function (assert) {
        const graph = await makeView({
            serverData,
            type: "graph",
            resModel: "helpdesk.ticket",
            groupBy: ["sla_deadline"],
            arch: `
                <graph js_class="helpdesk_ticket_graph">
                    <field name="sla_deadline"/>
                </graph>
            `,
            searchViewArch: `
                <search>
                    <filter name="group_by_sla_deadline" string="SLA Deadline" context="{ 'group_by': 'sla_deadline:day' }"/>
                </search>
            `,
        });
        checkLabels(assert, graph, ["Deadline reached"]);
        checkLegend(assert, graph, ["Count"]);

        await selectMode(target, "pie");

        checkLabels(assert, graph, ["Deadline reached"]);
        checkLegend(assert, graph, ["Deadline reached"]);
    });

    QUnit.test(
        "Verify ghost column is visible when all task stages are deleted in Task Kanban view",
        async function (assert) {
            const { openView } = await start({
                serverData,
            });
            await openView({
                res_model: "helpdesk.ticket",
                views: [[false, "kanban"]],
                context: {
                    active_model: "helpdesk.stage.delete.wizard", // simulate stage deletion wizard
                    default_team_id: 2,
                },
                domain: [["team_id", "=", 2]],
            });

            // Assertions to check for ghost column visibility
            assert.containsN(target, ".o_kanban_header", 1, "should have 1 column");
            assert.containsOnce(target, ".o_column_quick_create");
            assert.containsN(
                target,
                ".o_kanban_example_background_container",
                1,
                "Ghost column is visible"
            );
        }
    );
});