// The Lucia project.
// Copyright 2026-2026 DSP, inc.  All rights reserved.
// Authors:
//   imacat.yang@dsp.im (imacat), 2026/03/05

import { describe, it, expect, beforeEach, vi } from "vitest";
import { setActivePinia, createPinia } from "pinia";

vi.mock("@/module/apiError.js", () => ({
  default: vi.fn(),
}));

const { mockGet, mockPost, mockPut } = vi.hoisted(() => ({
  mockGet: vi.fn(),
  mockPost: vi.fn(),
  mockPut: vi.fn(),
}));
vi.mock("@/api/client.js", () => ({
  default: { get: mockGet, post: mockPost, put: mockPut },
}));

import { useAllMapDataStore } from "@/stores/allMapData";

describe("allMapDataStore", () => {
  let store;

  beforeEach(() => {
    setActivePinia(createPinia());
    store = useAllMapDataStore();
    vi.clearAllMocks();
  });

  it("has correct default state", () => {
    expect(store.logId).toBeNull();
    expect(store.allProcessMap).toEqual({});
    expect(store.allTrace).toEqual([]);
  });

  describe("getAllMapData", () => {
    it("fetches log discover data", async () => {
      store.logId = 1;
      const mockData = {
        process_map: { nodes: [] },
        bpmn: { nodes: [] },
        stats: { cases: 10 },
        insights: {},
      };
      mockGet.mockResolvedValue({ data: mockData });

      await store.getAllMapData();

      expect(mockGet).toHaveBeenCalledWith("/api/logs/1/discover");
      expect(store.allProcessMap).toEqual({ nodes: [] });
      expect(store.allStats).toEqual({ cases: 10 });
    });

    it("fetches temp filter discover data when set", async () => {
      store.logId = 1;
      store.tempFilterId = 5;
      mockGet.mockResolvedValue({
        data: {
          process_map: {},
          bpmn: {},
          stats: {},
          insights: {},
        },
      });

      await store.getAllMapData();

      expect(mockGet).toHaveBeenCalledWith("/api/temp-filters/5/discover");
    });

    it("fetches created filter discover data", async () => {
      store.logId = 1;
      store.createFilterId = 3;
      mockGet.mockResolvedValue({
        data: {
          process_map: {},
          bpmn: {},
          stats: {},
          insights: {},
        },
      });

      await store.getAllMapData();

      expect(mockGet).toHaveBeenCalledWith("/api/filters/3/discover");
    });

    it("does not throw on API failure", async () => {
      store.logId = 1;
      mockGet.mockRejectedValue(new Error("fail"));

      await expect(store.getAllMapData()).resolves.not.toThrow();
    });
  });

  describe("getFilterParams", () => {
    it("fetches filter params and transforms timeframe", async () => {
      store.logId = 1;
      const mockData = {
        tasks: ["A", "B"],
        sources: ["A"],
        sinks: ["B"],
        timeframe: {
          x_axis: {
            min: "2023-01-01T00:00:00Z",
            max: "2023-12-31T00:00:00Z",
          },
        },
        trace: [],
        attrs: [],
      };
      mockGet.mockResolvedValue({ data: mockData });

      await store.getFilterParams();

      expect(mockGet).toHaveBeenCalledWith("/api/filters/params?log_id=1");
      expect(store.allFilterTask).toEqual(["A", "B"]);
      // Check that min_base and max_base are stored
      expect(store.allFilterTimeframe.x_axis.min_base).toBe(
        "2023-01-01T00:00:00Z",
      );
    });
  });

  describe("checkHasResult", () => {
    it("posts rule data and stores result", async () => {
      store.logId = 1;
      store.postRuleData = [{ type: "task" }];
      mockPost.mockResolvedValue({
        data: { result: true },
      });

      await store.checkHasResult();

      expect(mockPost).toHaveBeenCalledWith(
        "/api/filters/has-result?log_id=1",
        [{ type: "task" }],
      );
      expect(store.hasResultRule).toBe(true);
    });
  });

  describe("addTempFilterId", () => {
    it("creates temp filter and stores id", async () => {
      store.logId = 1;
      store.postRuleData = [];
      mockPost.mockResolvedValue({ data: { id: 77 } });

      await store.addTempFilterId();

      expect(store.tempFilterId).toBe(77);
    });
  });

  describe("addFilterId", () => {
    it("creates filter and clears temp id", async () => {
      store.logId = 1;
      store.tempFilterId = 77;
      store.postRuleData = [{ type: "rule" }];
      mockPost.mockResolvedValue({ data: { id: 88 } });

      await store.addFilterId("myFilter");

      expect(mockPost).toHaveBeenCalledWith("/api/filters?log_id=1", {
        name: "myFilter",
        rules: [{ type: "rule" }],
      });
      expect(store.createFilterId).toBe(88);
      expect(store.tempFilterId).toBeNull();
    });
  });

  describe("updateFilter", () => {
    it("updates filter and clears temp id", async () => {
      store.createFilterId = 88;
      store.tempFilterId = 77;
      store.postRuleData = [{ type: "updated" }];
      mockPut.mockResolvedValue({ status: 200 });

      await store.updateFilter();

      expect(mockPut).toHaveBeenCalledWith("/api/filters/88", [
        { type: "updated" },
      ]);
      expect(store.isUpdateFilter).toBe(true);
      expect(store.tempFilterId).toBeNull();
    });
  });

  describe("getAllTrace", () => {
    it("does not crash when baseLogId is falsy", async () => {
      store.logId = 1;
      store.baseLogId = null;
      mockGet.mockResolvedValue({ data: [{ id: 1 }] });

      await store.getAllTrace();

      expect(store.allTrace).toEqual([{ id: 1 }]);
      // allBaseTrace should not be set when baseLogId is falsy
      expect(store.allBaseTrace).toEqual([]);
    });
  });

  describe("getters", () => {
    it("traces getter sorts by id", () => {
      store.allTrace = [
        { id: 3, name: "C" },
        { id: 1, name: "A" },
        { id: 2, name: "B" },
      ];
      expect(store.traces.map((t) => t.id)).toEqual([1, 2, 3]);
    });

    it("processMap getter returns state", () => {
      store.allProcessMap = { nodes: [1, 2] };
      expect(store.processMap).toEqual({ nodes: [1, 2] });
    });

    it("BaseInfiniteFirstCases returns allBaseCase when baseInfiniteStart is 0", () => {
      store.baseInfiniteStart = 0;
      store.allBaseCase = [{ id: 1 }, { id: 2 }];
      expect(store.BaseInfiniteFirstCases).toEqual([{ id: 1 }, { id: 2 }]);
    });

    it("BaseInfiniteFirstCases returns undefined when baseInfiniteStart is not 0", () => {
      store.baseInfiniteStart = 5;
      store.allBaseCase = [{ id: 1 }];
      expect(store.BaseInfiniteFirstCases).toBeUndefined();
    });

    it("filterAttrs getter does not corrupt original state on repeated access", () => {
      const originalDate = "2023-06-15T10:30:00Z";
      store.allFilterAttrs = [
        { type: "date", min: originalDate, max: "2023-12-31T23:59:00Z" },
      ];
      // Access the getter once
      store.filterAttrs;
      // The original state should still contain the ISO date, not a formatted string
      expect(store.allFilterAttrs[0].min).toBe(originalDate);
    });

    it("filterAttrs getter returns consistent float values on repeated access", () => {
      store.allFilterAttrs = [{ type: "float", min: 1.239, max: 5.671 }];
      const first = store.filterAttrs;
      const second = store.filterAttrs;
      // min rounds down (ROUND_DOWN=1), max rounds up (ROUND_UP=0)
      // Both accesses should produce the same result
      expect(first[0].min).toBe(second[0].min);
      expect(first[0].max).toBe(second[0].max);
    });
  });
});