import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { get } from "svelte/store";
import { editorStore } from "$lib/stores/editor";
import { setMockInvokeResult } from "../../../vitest.setup";

const FILE_CONTENT = "// test file content";

// Reset tabs between tests
afterEach(async () => {
  const tabs = get(editorStore.tabs);
  for (const tab of tabs) {
    editorStore.closeTab(tab.id);
  }
  editorStore.hideEditor();
});

describe("editorStore - openFile (tests getLanguageFromPath)", () => {
  const testCases: [string, string][] = [
    ["file.ts", "typescript"],
    ["file.tsx", "typescript"],
    ["file.js", "javascript"],
    ["file.jsx", "javascript"],
    ["file.py", "python"],
    ["file.rs", "rust"],
    ["file.go", "go"],
    ["file.java", "java"],
    ["file.c", "c"],
    ["file.cpp", "cpp"],
    ["file.h", "c"],
    ["file.hpp", "cpp"],
    ["file.cs", "csharp"],
    ["file.rb", "ruby"],
    ["file.php", "php"],
    ["file.swift", "swift"],
    ["file.kt", "kotlin"],
    ["file.scala", "scala"],
    ["file.html", "html"],
    ["file.htm", "html"],
    ["file.css", "css"],
    ["file.scss", "scss"],
    ["file.sass", "sass"],
    ["file.less", "less"],
    ["file.json", "json"],
    ["file.xml", "xml"],
    ["file.yaml", "yaml"],
    ["file.yml", "yaml"],
    ["file.toml", "toml"],
    ["file.md", "markdown"],
    ["file.markdown", "markdown"],
    ["file.sql", "sql"],
    ["file.sh", "shell"],
    ["file.bash", "shell"],
    ["file.zsh", "shell"],
    ["file.ps1", "powershell"],
    ["file.svelte", "svelte"],
    ["file.vue", "vue"],
    ["file.graphql", "graphql"],
    ["file.gql", "graphql"],
    ["file.lua", "lua"],
    ["file.r", "r"],
    ["file.dart", "dart"],
    ["file.elm", "elm"],
    ["file.ex", "elixir"],
    ["file.exs", "elixir"],
    ["file.erl", "erlang"],
    ["file.hs", "haskell"],
    ["file.clj", "clojure"],
    ["file.lisp", "lisp"],
    ["file.ml", "ocaml"],
    ["file.fs", "fsharp"],
    ["file.zig", "zig"],
    ["file.nim", "nim"],
    ["file.v", "v"],
    ["file.wasm", "wasm"],
    ["file.wat", "wasm"],
    ["dockerfile", "plaintext"],
    ["file.unknown", "plaintext"],
    ["file", "plaintext"],
  ];

  it.each(testCases)("maps %s to language %s", async (filename, expectedLanguage) => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile(`/path/to/${filename}`);
    const activeTab = get(editorStore.activeTab);
    expect(activeTab?.language).toBe(expectedLanguage);
    if (activeTab) editorStore.closeTab(activeTab.id);
  });

  it("opens a new tab and makes it active", async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file.ts");
    const tabs = get(editorStore.tabs);
    const activeTab = get(editorStore.activeTab);
    expect(tabs).toHaveLength(1);
    expect(activeTab?.fileName).toBe("file.ts");
    expect(activeTab?.content).toBe(FILE_CONTENT);
    expect(activeTab?.isDirty).toBe(false);
  });

  it("switches to existing tab instead of opening a duplicate", async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file.ts");
    const firstTabId = get(editorStore.activeTabId);

    // Open another file to change active tab
    await editorStore.openFile("/path/to/other.ts");
    const secondTabId = get(editorStore.activeTabId);
    expect(secondTabId).not.toBe(firstTabId);

    // Re-open first file — should switch to existing tab
    await editorStore.openFile("/path/to/file.ts");
    expect(get(editorStore.activeTabId)).toBe(firstTabId);
    expect(get(editorStore.tabs)).toHaveLength(2);
  });

  it("handles open file errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("read_file_content", new Error("File not found"));
    await editorStore.openFile("/path/to/missing.ts");
    expect(get(editorStore.tabs)).toHaveLength(0);
    expect(get(editorStore.saveError)).toContain("Failed to open file");
    consoleErrorSpy.mockRestore();
  });

  it("extracts filename from path correctly", async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/deep/nested/path/component.svelte");
    expect(get(editorStore.activeTab)?.fileName).toBe("component.svelte");
  });
});

describe("editorStore - saveFile", () => {
  beforeEach(async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file.ts");
    // Make it dirty first
    editorStore.updateTabContent(get(editorStore.activeTabId)!, "modified content");
  });

  it("saves the active tab successfully", async () => {
    setMockInvokeResult("write_file_content", undefined);
    await editorStore.saveFile();
    expect(get(editorStore.activeTab)?.isDirty).toBe(false);
    expect(get(editorStore.activeTab)?.originalContent).toBe("modified content");
  });

  it("saves a specific tab by ID", async () => {
    setMockInvokeResult("write_file_content", undefined);
    const tabId = get(editorStore.activeTabId)!;
    await editorStore.saveFile(tabId);
    expect(get(editorStore.activeTab)?.isDirty).toBe(false);
  });

  it("does nothing when no tab ID matches", async () => {
    await editorStore.saveFile("non-existent-tab");
    // No error = pass
  });
});

describe("editorStore - saveFile error", () => {
  it("sets saveError when write fails", async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file-err.ts");
    editorStore.updateTabContent(get(editorStore.activeTabId)!, "modified content");
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("write_file_content", new Error("Permission denied"));
    await editorStore.saveFile().catch(() => {});
    expect(get(editorStore.saveError)).toContain("Failed to save file");
    consoleErrorSpy.mockRestore();
  });
});

describe("editorStore - updateTabContent", () => {
  beforeEach(async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file.ts");
  });

  it("updates content and marks tab as dirty", () => {
    const tabId = get(editorStore.activeTabId)!;
    editorStore.updateTabContent(tabId, "new content");
    const tab = get(editorStore.activeTab);
    expect(tab?.content).toBe("new content");
    expect(tab?.isDirty).toBe(true);
  });

  it("marks tab as clean when content matches original", () => {
    const tabId = get(editorStore.activeTabId)!;
    editorStore.updateTabContent(tabId, "modified");
    expect(get(editorStore.activeTab)?.isDirty).toBe(true);
    editorStore.updateTabContent(tabId, FILE_CONTENT);
    expect(get(editorStore.activeTab)?.isDirty).toBe(false);
  });

  it("hasDirtyTabs is true when any tab is dirty", () => {
    const tabId = get(editorStore.activeTabId)!;
    expect(get(editorStore.hasDirtyTabs)).toBe(false);
    editorStore.updateTabContent(tabId, "dirty content");
    expect(get(editorStore.hasDirtyTabs)).toBe(true);
  });
});

describe("editorStore - closeTab", () => {
  beforeEach(async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file1.ts");
    await editorStore.openFile("/path/to/file2.ts");
  });

  it("removes the specified tab", () => {
    const tabs = get(editorStore.tabs);
    editorStore.closeTab(tabs[0].id);
    expect(get(editorStore.tabs)).toHaveLength(1);
    expect(get(editorStore.tabs)[0].filePath).toBe("/path/to/file2.ts");
  });

  it("sets active tab to remaining tab when active tab is closed", () => {
    const activeTabId = get(editorStore.activeTabId)!;
    editorStore.closeTab(activeTabId);
    expect(get(editorStore.activeTabId)).not.toBe(activeTabId);
    expect(get(editorStore.tabs)).toHaveLength(1);
  });
});

describe("editorStore - setActiveTab", () => {
  beforeEach(async () => {
    setMockInvokeResult("read_file_content", FILE_CONTENT);
    await editorStore.openFile("/path/to/file1.ts");
    await editorStore.openFile("/path/to/file2.ts");
  });

  it("sets the active tab to the specified ID", () => {
    const tabs = get(editorStore.tabs);
    editorStore.setActiveTab(tabs[0].id);
    expect(get(editorStore.activeTabId)).toBe(tabs[0].id);
  });
});

describe("editorStore - visibility controls", () => {
  it("showEditor sets isEditorVisible to true", () => {
    expect(get(editorStore.isEditorVisible)).toBe(false);
    editorStore.showEditor();
    expect(get(editorStore.isEditorVisible)).toBe(true);
  });

  it("hideEditor sets isEditorVisible to false", () => {
    editorStore.showEditor();
    editorStore.hideEditor();
    expect(get(editorStore.isEditorVisible)).toBe(false);
  });

  it("toggleEditor toggles isEditorVisible", () => {
    expect(get(editorStore.isEditorVisible)).toBe(false);
    editorStore.toggleEditor();
    expect(get(editorStore.isEditorVisible)).toBe(true);
    editorStore.toggleEditor();
    expect(get(editorStore.isEditorVisible)).toBe(false);
  });
});

describe("editorStore - toggleFileBrowser", () => {
  it("toggles the file browser visibility", () => {
    const initial = get(editorStore.isFileBrowserOpen);
    editorStore.toggleFileBrowser();
    expect(get(editorStore.isFileBrowserOpen)).toBe(!initial);
    editorStore.toggleFileBrowser();
    expect(get(editorStore.isFileBrowserOpen)).toBe(initial);
  });
});

describe("editorStore - file system operations", () => {
  it("createFile invokes backend and refreshes directory", async () => {
    setMockInvokeResult("create_file", undefined);
    setMockInvokeResult("list_directory", []);
    await editorStore.createFile("/path/to", "new-file.ts");
    // No error = success
  });

  it("createFile handles errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("create_file", new Error("Permission denied"));
    await editorStore.createFile("/path/to", "new-file.ts");
    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to create file:", expect.any(Error));
    consoleErrorSpy.mockRestore();
  });

  it("createDirectory invokes backend and refreshes", async () => {
    setMockInvokeResult("create_directory", undefined);
    setMockInvokeResult("list_directory", []);
    await editorStore.createDirectory("/path/to", "new-dir");
  });

  it("createDirectory handles errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("create_directory", new Error("Failed"));
    await editorStore.createDirectory("/path/to", "new-dir");
    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to create directory:", expect.any(Error));
    consoleErrorSpy.mockRestore();
  });

  it("deleteFile invokes backend and refreshes", async () => {
    setMockInvokeResult("delete_file", undefined);
    setMockInvokeResult("list_directory", []);
    await editorStore.deleteFile("/path/to/file.ts");
  });

  it("deleteFile handles errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("delete_file", new Error("Failed"));
    await editorStore.deleteFile("/path/to/file.ts");
    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to delete file:", expect.any(Error));
    consoleErrorSpy.mockRestore();
  });

  it("deleteDirectory invokes backend and refreshes", async () => {
    setMockInvokeResult("delete_directory", undefined);
    setMockInvokeResult("list_directory", []);
    await editorStore.deleteDirectory("/path/to/dir");
  });

  it("deleteDirectory handles errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("delete_directory", new Error("Failed"));
    await editorStore.deleteDirectory("/path/to/dir");
    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to delete directory:", expect.any(Error));
    consoleErrorSpy.mockRestore();
  });

  it("renamePath invokes backend and refreshes", async () => {
    setMockInvokeResult("rename_path", undefined);
    setMockInvokeResult("list_directory", []);
    await editorStore.renamePath("/path/to/old-name.ts", "new-name.ts");
  });

  it("renamePath handles errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("rename_path", new Error("Failed"));
    await editorStore.renamePath("/path/to/old-name.ts", "new-name.ts");
    expect(consoleErrorSpy).toHaveBeenCalledWith("Failed to rename:", expect.any(Error));
    consoleErrorSpy.mockRestore();
  });
});

describe("editorStore - initializeFileTree", () => {
  it("loads directory entries and updates file tree", async () => {
    const entries = [
      { path: "/path/file.ts", name: "file.ts", isDirectory: false, children: undefined },
    ];
    setMockInvokeResult("list_directory", entries);
    await editorStore.initializeFileTree("/path");
    expect(get(editorStore.fileTree)).toEqual(entries);
    expect(get(editorStore.currentDirectory)).toBe("/path");
  });

  it("handles errors gracefully", async () => {
    const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
    setMockInvokeResult("list_directory", new Error("Failed"));
    await editorStore.initializeFileTree("/path");
    expect(get(editorStore.isLoadingTree)).toBe(false);
    consoleErrorSpy.mockRestore();
  });
});