/**
 * Интеграционные тесты для автоматического создания и управления временным проектом
 */

import { invoke } from "@tauri-apps/api/core"
import { appDataDir, basename, join } from "@tauri-apps/api/path"
import { open, save } from "@tauri-apps/plugin-dialog"
import { exists, readTextFile, writeTextFile } from "@tauri-apps/plugin-fs"
import { act, renderHook, waitFor } from "@testing-library/react"
import { ReactNode } from "react"
// Import Tauri modules - они автоматически мокаются через алиасы в vitest.config.ts
import { beforeEach, describe, expect, it, vi } from "vitest"

import { AppProvider } from "../../services/app-provider"

// Mock nanoid
vi.mock("nanoid", () => ({
  nanoid: () => `test-id-${Math.random().toString(36).substring(2, 11)}`,
}))

// Mock useAppSettings to provide all methods needed by useCurrentProject
const mockCurrentProject = {
  path: null as string | null,
  name: "Untitled Project",
  isDirty: false,
  isNew: true,
}

// Import mocked function here to use in implementation
const { writeTextFile: mockWriteTextFile } = await import("@tauri-apps/plugin-fs")

const mockAppSettings = {
  getCurrentProject: vi.fn(() => mockCurrentProject),
  createNewProject: vi.fn(),
  createTempProject: vi.fn().mockImplementation(async () => {
    mockCurrentProject.path = "/app/backup/temp_project.tlsp"
    mockCurrentProject.isDirty = true
    // Вызываем writeTextFile как в реальной реализации
    await mockWriteTextFile("/app/backup/temp_project.tlsp", JSON.stringify(mockCurrentProject))
    return mockCurrentProject
  }),
  loadOrCreateTempProject: vi.fn(),
  openProject: vi.fn(),
  saveProject: vi.fn().mockImplementation(async (name: string) => {
    mockCurrentProject.name = name
    mockCurrentProject.path = "/user/my-project.tlsp"
    mockCurrentProject.isDirty = false
    return { path: "/user/my-project.tlsp", name }
  }),
  setProjectDirty: vi.fn().mockImplementation((dirty: boolean) => {
    mockCurrentProject.isDirty = dirty
  }),
  isTempProject: vi.fn(() => mockCurrentProject.path?.includes("temp_project.tlsp") ?? false),
}

vi.mock("@/features/app-state/hooks/use-app-settings", () => ({
  useAppSettings: () => mockAppSettings,
}))

// Mock useCurrentProject hook directly
vi.mock("@/features/app-state/hooks/use-current-project", async () => {
  const actual = await vi.importActual("@/features/app-state/hooks/use-current-project")
  return {
    ...actual,
    useCurrentProject: () => ({
      currentProject: mockCurrentProject,
      ...mockAppSettings,
    }),
  }
})

// Import after mocks
const { useCurrentProject } = await import("@/features/app-state/hooks/use-current-project")

// Mock media restoration
vi.mock("@/features/media/hooks/use-media-restoration", () => ({
  useMediaRestoration: () => ({
    restoreProjectMedia: vi.fn(),
    handleMissingFilesResolution: vi.fn(),
    cancelMissingFilesDialog: vi.fn(),
    showMissingFilesDialog: false,
    getMissingFiles: () => [],
  }),
}))

// Mock TimelineStudioProjectService
vi.mock("@/features/app-state/services/timeline-studio-project-service", () => ({
  TimelineStudioProjectService: {
    getInstance: () => ({
      createProject: vi.fn().mockResolvedValue({
        metadata: {
          id: "test-project-id",
          name: "Untitled Project",
          version: "2.0.0",
          created: new Date().toISOString(),
          modified: new Date().toISOString(),
          platform: "macos",
          appVersion: "1.0.0",
        },
        settings: {},
        mediaPool: {
          items: new Map(),
          bins: { root: { id: "root", name: "Media Pool" } },
          smartCollections: [],
          viewSettings: {},
          stats: {},
        },
        sequences: new Map([["seq-1", { id: "seq-1", name: "Main Sequence", type: "main" }]]),
        activeSequenceId: "seq-1",
        cache: {
          thumbnails: {},
          waveforms: {},
          proxies: {},
          sceneAnalysis: {},
        },
        workspace: {},
        backup: {
          autoSave: { enabled: true, interval: 5, keepVersions: 10 },
          versions: [],
          lastSaved: new Date().toISOString(),
        },
      }),
      saveProject: vi.fn().mockImplementation(async (project, path) => {
        console.log(`Project saved to ${path}`)
        // Simulate calling writeTextFile like the real implementation does
        await vi.mocked(writeTextFile)(path, JSON.stringify(project, null, 2))
        return Promise.resolve()
      }),
      openProject: vi.fn().mockImplementation(async (path) => {
        if (path.includes("temp_project.tlsp")) {
          // Return a temp project when loading temp project
          return {
            metadata: {
              id: "temp-project-id",
              name: "Untitled Project",
              version: "2.0.0",
              created: new Date(),
              modified: new Date(),
              platform: "macos",
              appVersion: "1.0.0",
            },
            settings: {},
            mediaPool: {
              items: new Map(),
              bins: new Map([["root", { id: "root", name: "Media Pool" }]]),
              smartCollections: [],
              viewSettings: {},
              stats: {},
            },
            sequences: new Map([["seq-1", { id: "seq-1", name: "Main Sequence", type: "main" }]]),
            activeSequenceId: "seq-1",
            cache: {
              thumbnails: new Map(),
              waveforms: new Map(),
              proxies: new Map(),
              sceneAnalysis: new Map(),
              totalSize: 0,
            },
            workspace: {},
            backup: {
              autoSave: { enabled: true, interval: 5, keepVersions: 10 },
              versions: [],
              lastSaved: new Date(),
            },
          }
        }
        // Default: project not found
        throw new Error("Project not found")
      }),
    }),
  },
}))

// Mock app directories service
vi.mock("@/features/app-state/services/app-directories-service", () => ({
  appDirectoriesService: {
    getAppDirectories: vi.fn().mockResolvedValue({
      app_dir: "/app/data",
      backup_dir: "/app/backup",
      projects_dir: "/app/projects",
      exports_dir: "/app/exports",
      cache_dir: "/app/cache",
      temp_dir: "/app/temp",
      media_dir: "/app/media",
      snapshot_dir: "/app/snapshots",
      cinematic_dir: "/app/cinematic",
      output_dir: "/app/output",
      render_dir: "/app/render",
      recognition_dir: "/app/recognition",
      media_proxy_dir: "/app/proxy",
      caches_dir: "/app/cache",
      recorded_dir: "/app/recorded",
      audio_dir: "/app/audio",
      cloud_project_dir: "/app/cloud",
      upload_dir: "/app/upload",
    }),
    createAppDirectories: vi.fn().mockResolvedValue(undefined),
  },
}))

// Mock store service to prevent actual store initialization
vi.mock("@/features/app-state/services/store-service", () => {
  const mockStoreInstance = {
    initialize: vi.fn().mockResolvedValue(undefined),
    getSettings: vi.fn().mockResolvedValue({
      userSettings: {
        previewSizes: {
          MEDIA: 200,
          TRANSITIONS: 200,
          TEMPLATES: 200,
          EFFECTS: 200,
          FILTERS: 200,
          SUBTITLES: 200,
          STYLE_TEMPLATES: 200,
          MUSIC: 125,
        },
        activeTab: "media",
        layoutMode: "default",
        screenshotsPath: "",
        playerScreenshotsPath: "",
        playerVolume: 100,
        openAiApiKey: "",
        claudeApiKey: "",
        youtubeClientId: "",
        youtubeClientSecret: "",
        tiktokClientId: "",
        tiktokClientSecret: "",
        vimeoClientId: "",
        vimeoClientSecret: "",
        vimeoAccessToken: "",
        telegramBotToken: "",
        telegramChatId: "",
        codecovToken: "",
        tauriAnalyticsKey: "",
        gpuAccelerationEnabled: true,
        preferredGpuEncoder: "auto",
        maxConcurrentJobs: 2,
        renderQuality: "high",
        backgroundRenderingEnabled: true,
        renderDelay: 0,
        proxyEnabled: false,
        proxyType: "http",
        proxyHost: "",
        proxyPort: "",
        proxyUsername: "",
        proxyPassword: "",
        apiKeysStatus: {},
        autoSaveEnabled: true,
        autoSaveInterval: 60,
        isBrowserVisible: true,
        isOptionsVisible: true,
        isTimelineVisible: true,
        isAIAssistantVisible: false,
        isLoaded: true,
      },
      recentProjects: [],
      currentProject: {
        path: null,
        name: "Untitled Project",
        isDirty: false,
        isNew: true,
      },
      mediaFiles: {
        allFiles: [],
        error: null,
        isLoading: false,
      },
      musicFiles: {
        allFiles: [],
        error: null,
        isLoading: false,
      },
      favorites: {
        media: [],
        music: [],
        transition: [],
        effect: [],
        template: [],
        filter: [],
        subtitle: [],
        styleTemplate: [],
      },
      meta: {
        lastUpdated: Date.now(),
        version: "1.0.0",
      },
    }),
    saveSettings: vi.fn().mockResolvedValue(undefined),
    getUserSettings: vi.fn().mockResolvedValue(null),
    saveUserSettings: vi.fn().mockResolvedValue(undefined),
    getRecentProjects: vi.fn().mockResolvedValue([]),
    addRecentProject: vi.fn().mockResolvedValue(undefined),
    getFavorites: vi.fn().mockResolvedValue({
      media: [],
      music: [],
      transition: [],
      effect: [],
      template: [],
      filter: [],
      subtitle: [],
      styleTemplate: [],
    }),
    saveFavorites: vi.fn().mockResolvedValue(undefined),
  }

  return {
    StoreService: {
      getInstance: () => mockStoreInstance,
    },
    storeService: mockStoreInstance,
    USER_SETTINGS_STORE_PATH: ".timeline-studio-settings.json",
  }
})

// Test wrapper component
function TestWrapper({ children }: { children: ReactNode }) {
  return <AppProvider>{children}</AppProvider>
}

describe("Temporary Project Integration", () => {
  const mockDirectories = {
    base_dir: "/app",
    media_dir: "/app/media",
    projects_dir: "/app/projects",
    backup_dir: "/app/backup",
    snapshot_dir: "/app/snapshots",
    cinematic_dir: "/app/cinematic",
    output_dir: "/app/output",
    render_dir: "/app/render",
    recognition_dir: "/app/recognition",
    media_proxy_dir: "/app/proxy",
    caches_dir: "/app/cache",
    recorded_dir: "/app/recorded",
    audio_dir: "/app/audio",
    cloud_project_dir: "/app/cloud",
    upload_dir: "/app/upload",
  }

  beforeEach(() => {
    vi.clearAllMocks()

    // Reset mock project state
    mockCurrentProject.path = null
    mockCurrentProject.name = "Untitled Project"
    mockCurrentProject.isDirty = false
    mockCurrentProject.isNew = true

    // Mock app directories
    vi.mocked(invoke).mockImplementation((command) => {
      if (command === "get_app_directories" || command === "create_app_directories") {
        return Promise.resolve(mockDirectories)
      }
      return Promise.resolve()
    })

    // Mock file operations
    vi.mocked(readTextFile).mockRejectedValue(new Error("File not found"))
    vi.mocked(writeTextFile).mockResolvedValue()
    vi.mocked(exists).mockResolvedValue(false)

    vi.mocked(join).mockImplementation((...parts) => Promise.resolve(parts.join("/")))
    vi.mocked(appDataDir).mockResolvedValue("/app/data")
    vi.mocked(basename).mockImplementation((path) => Promise.resolve(path.split("/").pop() || ""))
    vi.mocked(open).mockResolvedValue(null)
    vi.mocked(save).mockResolvedValue(null)
  })

  describe("Automatic Temp Project Creation", () => {
    it("should create temp project manually", async () => {
      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Wait for provider to be ready
      await act(async () => {
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Manually create temp project
      await act(async () => {
        await result.current.createTempProject()
      })

      // Should have temp project path
      expect(result.current.currentProject.path).toContain("temp_project.tlsp")
      expect(result.current.currentProject.name).toBe("Untitled Project")
      expect(result.current.currentProject.isDirty).toBe(true)
      expect(result.current.isTempProject()).toBe(true)

      // Should have called save
      expect(writeTextFile).toHaveBeenCalledWith("/app/backup/temp_project.tlsp", expect.any(String))
    })

    it.skip("should load existing temp project if it exists", async () => {
      // Mock existing temp project file
      const existingProject = {
        metadata: {
          id: "existing-temp",
          name: "Existing Temp Project",
          version: "2.0.0",
          created: new Date().toISOString(),
          modified: new Date().toISOString(),
          platform: "macos",
          appVersion: "1.0.0",
        },
        settings: {},
        mediaPool: {
          items: {},
          bins: { root: { id: "root", name: "Media Pool" } },
          smartCollections: [],
          viewSettings: {},
          stats: {},
        },
        sequences: {
          "seq-1": { id: "seq-1", name: "Main Sequence", type: "main" },
        },
        activeSequenceId: "seq-1",
        cache: {
          thumbnails: {},
          waveforms: {},
          proxies: {},
          sceneAnalysis: {},
        },
        workspace: {},
        backup: {
          autoSave: { enabled: true, interval: 5, keepVersions: 10 },
          versions: [],
          lastSaved: new Date().toISOString(),
        },
      }

      // Mock exists to return true for temp project file
      vi.mocked(exists).mockImplementation((path) => {
        if (path === "/app/backup/temp_project.tlsp") {
          return Promise.resolve(true)
        }
        return Promise.resolve(false)
      })

      // Mock readTextFile to simulate an existing temp project
      vi.mocked(readTextFile).mockImplementation((path) => {
        if (path === "/app/backup/temp_project.tlsp") {
          return Promise.resolve(JSON.stringify(existingProject))
        }
        return Promise.reject(new Error("File not found"))
      })

      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Log initial state
      console.log("Test: initial state", {
        path: result.current.currentProject.path,
        name: result.current.currentProject.name,
        isNew: result.current.currentProject.isNew,
      })

      // Wait for the async effect to complete
      await act(async () => {
        // Give time for the useEffect to trigger and loadOrCreateTempProject to run
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Ждем загрузки проекта - используем polling для проверки изменения состояния
      await waitFor(
        () => {
          const path = result.current.currentProject.path
          const name = result.current.currentProject.name
          const isNew = result.current.currentProject.isNew
          console.log("Test: waiting for project load", { path, name, isNew })

          // Проверяем, что проект загрузился (путь установлен и это не новый проект)
          expect(path).toBeTruthy()
          expect(path).toContain("temp_project.tlsp")
          expect(isNew).toBe(false)
        },
        { timeout: 5000, interval: 100 },
      )

      // Проверяем имя проекта
      expect(result.current.currentProject.name).toBe("Existing Temp Project")
      expect(result.current.currentProject.isDirty).toBe(false)
      expect(result.current.isTempProject()).toBe(true)
    })
  })

  describe("Temp Project Auto-save", () => {
    it("should mark temp project as dirty when changed", async () => {
      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Wait for provider to be ready
      await act(async () => {
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Manually create temp project
      await act(async () => {
        await result.current.createTempProject()
      })

      // Should be dirty by default
      expect(result.current.currentProject.isDirty).toBe(true)

      // Trigger marking as dirty
      result.current.setProjectDirty(true)

      // Should still be dirty
      expect(result.current.currentProject.isDirty).toBe(true)

      // NOTE: Auto-save is currently disabled to prevent file conflicts
      // as noted in the autoSaveTempProject function
    })
  })

  describe("Saving Temp Project as New File", () => {
    it("should convert temp project to regular project when saving", async () => {
      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Wait for provider to be ready
      await act(async () => {
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Manually create temp project
      await act(async () => {
        await result.current.createTempProject()
      })

      // Mock save dialog
      vi.mocked(save).mockResolvedValue("/user/my-project.tlsp")

      // Mock reading temp project for save
      vi.mocked(readTextFile).mockResolvedValue(
        JSON.stringify({
          metadata: {
            name: "Untitled Project",
            version: "2.0.0",
            modified: new Date().toISOString(),
            created: new Date().toISOString(),
            platform: "macos",
            appVersion: "1.0.0",
            id: "temp-id",
          },
          settings: {},
          mediaPool: { items: {}, bins: {} },
          sequences: {},
          activeSequenceId: "seq-1",
          cache: { thumbnails: {}, waveforms: {}, proxies: {}, sceneAnalysis: {} },
          workspace: {},
          backup: {
            autoSave: { enabled: true, interval: 5, keepVersions: 10 },
            versions: [],
            lastSaved: new Date().toISOString(),
          },
        }),
      )

      // Save the project with new name
      const saveResult = await result.current.saveProject("My New Project")

      expect(saveResult).toEqual({
        path: "/user/my-project.tlsp",
        name: "My New Project",
      })

      // Should no longer be temp project
      await waitFor(() => {
        expect(result.current.currentProject.isDirty).toBe(false)
        expect(result.current.isTempProject()).toBe(false)
      })
    })
  })

  describe("Temp Project Management", () => {
    it("should provide utility methods for temp project detection", async () => {
      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Wait for provider to be ready
      await act(async () => {
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Manually create temp project
      await act(async () => {
        await result.current.createTempProject()
      })

      // Should detect temp project correctly
      expect(result.current.isTempProject()).toBe(true)

      // Should have correct temp project name
      expect(result.current.currentProject.name).toBe("Untitled Project")

      // Should be marked as dirty (needs saving)
      expect(result.current.currentProject.isDirty).toBe(true)
    })

    it("should create new temp project manually", async () => {
      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Wait for provider to be ready
      await act(async () => {
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Clear previous calls
      vi.mocked(writeTextFile).mockClear()

      // Create new temp project
      await act(async () => {
        await result.current.createTempProject()
      })

      // Should have created and saved new temp project
      expect(writeTextFile).toHaveBeenCalledWith("/app/backup/temp_project.tlsp", expect.any(String))

      expect(result.current.isTempProject()).toBe(true)
      expect(result.current.currentProject.isDirty).toBe(true)
    })
  })

  describe("Error Handling", () => {
    it("should fallback to regular project creation if temp project fails", async () => {
      // Mock directory service failure
      vi.mocked(invoke).mockImplementation((command) => {
        if (command === "get_app_directories" || command === "create_app_directories") {
          return Promise.reject(new Error("Directory service failed"))
        }
        return Promise.resolve()
      })

      vi.mocked(readTextFile).mockRejectedValue(new Error("File not found"))
      vi.mocked(writeTextFile).mockRejectedValue(new Error("Write failed"))

      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Should fallback to regular new project
      await waitFor(() => {
        expect(result.current.currentProject.isNew).toBe(true)
      })

      // Should not be a temp project
      expect(result.current.isTempProject()).toBe(false)
    })

    it("should handle temp project save failures gracefully", async () => {
      const { result } = renderHook(() => useCurrentProject(), {
        wrapper: TestWrapper,
      })

      // Wait for provider to be ready
      await act(async () => {
        await new Promise((resolve) => setTimeout(resolve, 100))
      })

      // Manually create temp project
      await act(async () => {
        await result.current.createTempProject()
      })

      // Mock save failure
      vi.mocked(readTextFile).mockResolvedValue(JSON.stringify({ metadata: {} }))
      vi.mocked(writeTextFile).mockRejectedValue(new Error("Save failed"))

      // Should not throw when auto-save fails
      expect(() => {
        result.current.setProjectDirty(true)
      }).not.toThrow()
    })
  })
})