import { render, renderHook, waitFor } from "@testing-library/react"
import React, { act } from "react"
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"

import { renderWithChat } from "@/test/test-utils"

import { useChat } from "../../hooks/use-chat"
import { ChatContext, ChatProvider } from "../../services/chat-provider"
import { ClaudeService } from "../../services/claude-service"
import { OpenAiService } from "../../services/open-ai-service"

import type { ChatListItem } from "../../types/chat"

// Mock user settings
vi.mock("@/features/user-settings", () => ({
  useUserSettings: () => ({
    openAiApiKey: "test-openai-key",
    claudeApiKey: "test-claude-key",
  }),
  UserSettingsProvider: ({ children }: { children: React.ReactNode }) => children,
}))

// Mock app settings
vi.mock("@/features/app-state", () => ({
  useAppSettings: () => ({
    settings: {},
  }),
  AppSettingsProvider: ({ children }: { children: React.ReactNode }) => children,
}))

// Mock modals
vi.mock("@/features/modals/services/modal-provider", () => ({
  ModalProvider: ({ children }: { children: React.ReactNode }) => children,
  useModal: () => ({
    openModal: vi.fn(),
    closeModal: vi.fn(),
    isOpen: false,
  }),
}))

// Mock theme
vi.mock("@/features/top-bar/components/theme/theme-context", () => ({
  ThemeProvider: ({ children }: { children: React.ReactNode }) => children,
  useTheme: () => ({ theme: "light", setTheme: vi.fn() }),
}))

// Mock i18n
vi.mock("@/i18n/services/i18n-provider", () => ({
  I18nProvider: ({ children }: { children: React.ReactNode }) => children,
}))

// Mock AI сервисы
vi.mock("../../services/claude-service", () => ({
  ClaudeService: {
    getInstance: vi.fn().mockReturnValue({
      setApiKey: vi.fn(),
      sendRequest: vi.fn().mockResolvedValue("Ответ от Claude"),
    }),
  },
}))

vi.mock("../../services/open-ai-service", () => ({
  OpenAiService: {
    getInstance: vi.fn().mockReturnValue({
      setApiKey: vi.fn(),
      sendRequest: vi.fn().mockResolvedValue("Ответ от OpenAI"),
    }),
  },
}))

describe("ChatProvider", () => {
  let claudeService: any
  let openAiService: any

  beforeEach(() => {
    vi.clearAllMocks()
    claudeService = ClaudeService.getInstance()
    openAiService = OpenAiService.getInstance()
  })

  afterEach(() => {
    vi.useRealTimers()
  })

  describe("Инициализация", () => {
    it("должен рендериться без ошибок", () => {
      const { container } = renderWithChat(<div>Тестовый контент</div>)

      expect(container).toBeTruthy()
      expect(container.textContent).toBe("Тестовый контент")
    })

    it("должен предоставлять контекст дочерним компонентам", () => {
      const TestComponent = () => {
        const context = React.useContext(ChatContext)
        return <div>{context ? "Контекст доступен" : "Контекст недоступен"}</div>
      }

      const { getByText } = renderWithChat(<TestComponent />)

      expect(getByText("Контекст доступен")).toBeInTheDocument()
    })

    it("должен инициализировать с правильным начальным состоянием", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      expect(result.current.chatMessages).toEqual([])
      expect(result.current.selectedAgentId).toBe("claude-4-sonnet")
      expect(result.current.isProcessing).toBe(false)
      expect(result.current.error).toBe(null)
    })
  })

  describe("Отправка сообщений", () => {
    it("должен отправлять сообщение пользователя", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      await act(async () => {
        await result.current.sendChatMessage("Привет, ИИ!")
      })

      expect(result.current.chatMessages).toHaveLength(1)
      expect(result.current.chatMessages[0]).toMatchObject({
        role: "user",
        content: "Привет, ИИ!",
      })
      expect(result.current.isProcessing).toBe(false) // После завершения должен быть false
    })

    it.skip("должен получать ответ от ИИ", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      await act(async () => {
        await result.current.sendChatMessage("Как дела?")
      })

      // Ждем обработку
      await waitFor(() => {
        expect(result.current.isProcessing).toBe(false)
      })

      expect(result.current.chatMessages).toHaveLength(2)
      expect(result.current.chatMessages[1]).toMatchObject({
        role: "assistant",
        content: "Ответ от Claude",
      })
    })

    it("не должен отправлять пустые сообщения", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      act(() => {
        void result.current.sendChatMessage("")
        void result.current.sendChatMessage("   ")
      })

      // Пустые сообщения могут быть добавлены в зависимости от реализации машины
      // Важно что они не обрабатываются дальше
      expect(result.current.chatMessages.length).toBeLessThanOrEqual(2)
    })
  })

  describe("Управление агентами", () => {
    it("должен переключать агента", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      expect(result.current.selectedAgentId).toBe("claude-4-sonnet")

      act(() => {
        result.current.selectAgent("gpt-4")
      })

      expect(result.current.selectedAgentId).toBe("gpt-4")
    })

    it.skip("должен использовать правильный сервис для выбранного агента", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Переключаем на GPT-4
      act(() => {
        result.current.selectAgent("gpt-4")
      })

      await act(async () => {
        await result.current.sendChatMessage("Тест GPT")
      })

      await waitFor(() => {
        expect(result.current.isProcessing).toBe(false)
      })

      expect(result.current.chatMessages[1].content).toBe("Ответ от OpenAI")
    })
  })

  describe("Управление сообщениями", () => {
    it.skip("должен удалять конкретное сообщение", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Добавляем несколько сообщений
      act(() => {
        void result.current.sendChatMessage("Сообщение 1")
      })

      const firstMessageId = result.current.chatMessages[0].id

      act(() => {
        result.current.receiveChatMessage("Ответ 1")
        void result.current.sendChatMessage("Сообщение 2")
      })

      expect(result.current.chatMessages).toHaveLength(3)

      // Удаляем первое сообщение
      act(() => {
        result.current.removeMessage(firstMessageId)
      })

      expect(result.current.chatMessages).toHaveLength(2)
      expect(result.current.chatMessages.find((m) => m.id === firstMessageId)).toBeUndefined()
    })

    it.skip("должен очищать все сообщения", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Добавляем сообщения
      act(() => {
        void result.current.sendChatMessage("Сообщение 1")
        result.current.receiveChatMessage("Ответ 1")
        void result.current.sendChatMessage("Сообщение 2")
      })

      expect(result.current.chatMessages.length).toBeGreaterThan(0)

      // Очищаем все
      act(() => {
        void result.current.clearMessages()
      })

      expect(result.current.chatMessages).toHaveLength(0)
    })
  })

  describe("Обработка ошибок", () => {
    it.skip("должен обрабатывать ошибки API", async () => {
      // Настраиваем мок для возврата ошибки
      const errorService = {
        sendMessage: vi.fn().mockRejectedValue(new Error("API недоступен")),
      }
      vi.mocked(ClaudeService.getInstance).mockReturnValue(errorService as any)

      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      await act(async () => {
        void result.current.sendChatMessage("Тест ошибки")
      })

      await waitFor(() => {
        expect(result.current.isProcessing).toBe(false)
      })

      expect(result.current.error).toBe("API недоступен")
      // Должно быть только сообщение пользователя, без ответа
      expect(result.current.chatMessages).toHaveLength(1)
    })

    it.skip("должен сбрасывать ошибку при новом сообщении", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Устанавливаем ошибку
      act(() => {
        result.current.setError("Старая ошибка")
      })

      expect(result.current.error).toBe("Старая ошибка")

      // Отправляем новое сообщение
      await act(async () => {
        void result.current.sendChatMessage("Новое сообщение")
      })

      expect(result.current.error).toBe(null)
    })
  })

  describe("Состояние обработки", () => {
    it.skip("должен правильно управлять состоянием isProcessing", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      expect(result.current.isProcessing).toBe(false)

      // Начинаем обработку
      const sendPromise = act(async () => {
        void result.current.sendChatMessage("Тест")
      })

      expect(result.current.isProcessing).toBe(true)

      // Ждем завершения
      await sendPromise
      await waitFor(() => {
        expect(result.current.isProcessing).toBe(false)
      })
    })

    it.skip("должен позволять ручное управление состоянием обработки", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      act(() => {
        result.current.setProcessing(true)
      })

      expect(result.current.isProcessing).toBe(true)

      act(() => {
        result.current.setProcessing(false)
      })

      expect(result.current.isProcessing).toBe(false)
    })
  })

  describe("Интеграция с машиной состояний", () => {
    it.skip("должен синхронизировать состояние с XState машиной", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Проверяем начальное состояние
      expect(result.current.chatMessages).toEqual([])

      // Выполняем действия
      act(() => {
        void result.current.sendChatMessage("Тест синхронизации")
      })

      // Проверяем, что состояние обновилось через машину
      expect(result.current.chatMessages).toHaveLength(1)
      expect(result.current.isProcessing).toBe(true)
    })
  })

  describe("Производительность", () => {
    it("не должен вызывать лишние рендеры", () => {
      let renderCount = 0

      const TestComponent = () => {
        renderCount++
        const { chatMessages } = useChat()
        return <div>{chatMessages.length}</div>
      }

      const { rerender } = render(
        <ChatProvider>
          <TestComponent />
        </ChatProvider>,
      )

      const initialRenderCount = renderCount

      // Перерендериваем провайдер с тем же содержимым
      rerender(
        <ChatProvider>
          <TestComponent />
        </ChatProvider>,
      )

      // Может быть один дополнительный рендер при перерендере провайдера
      expect(renderCount).toBeLessThanOrEqual(initialRenderCount + 1)
    })
  })

  describe("Параллельная обработка", () => {
    it.skip("должен обрабатывать быстрые последовательные сообщения", async () => {
      vi.useFakeTimers()

      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Ждем инициализации хука
      await waitFor(() => {
        expect(result.current).not.toBeNull()
        expect(result.current.sendChatMessage).toBeDefined()
      })

      // Отправляем несколько сообщений быстро
      act(() => {
        void result.current.sendChatMessage("Сообщение 1")
      })

      // Небольшая задержка
      act(() => {
        vi.advanceTimersByTime(100)
      })

      act(() => {
        void result.current.sendChatMessage("Сообщение 2")
      })

      // Проверяем, что оба сообщения пользователя добавлены
      expect(result.current.chatMessages.filter((m) => m.role === "user")).toHaveLength(2)

      // Продвигаем таймеры для завершения обработки
      await act(async () => {
        vi.runAllTimers()
      })

      // Должны быть ответы на оба сообщения
      await waitFor(() => {
        expect(result.current.chatMessages.filter((m) => m.role === "assistant")).toHaveLength(2)
      })

      vi.useRealTimers()
    })
  })

  describe("Управление сессиями", () => {
    it("должен создавать новый чат", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      expect(result.current.isCreatingNewChat).toBe(false)

      act(() => {
        void result.current.createNewChat()
      })

      expect(result.current.isCreatingNewChat).toBe(true)

      // Ждем пока создастся чат (1.5 секунды)
      await waitFor(
        () => {
          expect(result.current.isCreatingNewChat).toBe(false)
        },
        { timeout: 2000 },
      )

      expect(result.current.sessions.length).toBeGreaterThan(0)
      expect(result.current.currentSessionId).toBeTruthy()
    })

    it("должен переключать сессии", () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      const sessionId = "test-session-123"

      act(() => {
        void result.current.switchSession(sessionId)
      })

      expect(result.current.currentSessionId).toBe(sessionId)
      expect(result.current.chatMessages).toHaveLength(0)
    })

    it("должен удалять сессию", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      // Добавляем тестовые сессии
      const testSessions: ChatListItem[] = [
        {
          id: "session-1",
          title: "Тест 1",
          lastMessageAt: new Date(),
          messageCount: 5,
        },
        {
          id: "session-2",
          title: "Тест 2",
          lastMessageAt: new Date(),
          messageCount: 3,
        },
      ]

      await act(async () => {
        await result.current.updateSessions(testSessions)
        await result.current.switchSession("session-1")
      })

      expect(result.current.sessions).toHaveLength(2)
      expect(result.current.currentSessionId).toBe("session-1")

      await act(async () => {
        await result.current.deleteSession("session-1")
      })

      expect(result.current.sessions).toHaveLength(1)
      expect(result.current.currentSessionId).toBeNull()
    })

    it("должен обновлять список сессий", async () => {
      const { result } = renderHook(() => useChat(), {
        wrapper: ChatProvider,
      })

      const newSessions: ChatListItem[] = [
        {
          id: "new-1",
          title: "Новый чат 1",
          lastMessageAt: new Date(),
          messageCount: 10,
        },
        {
          id: "new-2",
          title: "Новый чат 2",
          lastMessageAt: new Date(),
          messageCount: 20,
        },
      ]

      await act(async () => {
        await result.current.updateSessions(newSessions)
      })

      // Проверяем, что сессии обновились правильно
      expect(result.current.sessions).toHaveLength(2)
      expect(result.current.sessions[0]).toMatchObject({
        id: "new-1",
        title: "Новый чат 1",
        messageCount: 10,
      })
      expect(result.current.sessions[1]).toMatchObject({
        id: "new-2",
        title: "Новый чат 2",
        messageCount: 20,
      })
    })
  })
})