import { describe, it, expect, vi, beforeEach } from "vitest";
import { renderHook, waitFor } from "@testing-library/react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import React, { ReactNode } from "react";
import { useTeams, useTeam, useDeletedTeams, DeletedTeam, teamListCall } from "./useTeams";
import { fetchTeams } from "@/app/(dashboard)/networking";
import { teamInfoCall } from "@/components/networking";
import type { Team } from "@/components/key_team_helpers/key_list";

vi.mock("@/app/(dashboard)/networking", () => ({
  fetchTeams: vi.fn(),
}));

vi.mock("@/components/networking", () => ({
  teamInfoCall: vi.fn(),
  getProxyBaseUrl: vi.fn(() => ""),
  getGlobalLitellmHeaderName: vi.fn(() => "Authorization"),
  deriveErrorMessage: vi.fn((data) => data?.error || "Error"),
  handleError: vi.fn(),
}));

const mockUseAuthorized = vi.fn();
vi.mock("@/app/(dashboard)/hooks/useAuthorized", () => ({
  default: () => mockUseAuthorized(),
}));

const mockTeams: Team[] = [
  {
    team_id: "team-1",
    team_alias: "Test Team 1",
    models: ["gpt-3.5-turbo", "claude-3"],
    max_budget: 100.0,
    budget_duration: "monthly",
    tpm_limit: 1000,
    rpm_limit: 100,
    organization_id: "org-1",
    created_at: "2024-01-01T00:00:00Z",
    keys: [],
    members_with_roles: [],
    spend: 50.0,
  },
  {
    team_id: "team-2",
    team_alias: "Test Team 2",
    models: ["gpt-4"],
    max_budget: 200.0,
    budget_duration: "monthly",
    tpm_limit: 2000,
    rpm_limit: 200,
    organization_id: "org-1",
    created_at: "2024-01-02T00:00:00Z",
    keys: [],
    members_with_roles: [],
    spend: 100.0,
  },
];

describe("useTeams", () => {
  let queryClient: QueryClient;

  beforeEach(() => {
    queryClient = new QueryClient({
      defaultOptions: {
        queries: {
          retry: false,
        },
      },
    });

    // Reset all mocks
    vi.clearAllMocks();

    // Set default mock for useAuthorized (enabled state)
    mockUseAuthorized.mockReturnValue({
      accessToken: "test-access-token",
      userId: "test-user-id",
      userRole: "Admin",
      token: "test-token",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });
  });

  const wrapper = ({ children }: { children: ReactNode }) =>
    React.createElement(QueryClientProvider, { client: queryClient }, children);

  it("should render", () => {
    (fetchTeams as any).mockResolvedValue(mockTeams);

    const { result } = renderHook(() => useTeams(), { wrapper });

    expect(result.current).toBeDefined();
  });

  it("should return teams data when query is successful", async () => {
    // Mock successful API call
    (fetchTeams as any).mockResolvedValue(mockTeams);

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Initially loading
    expect(result.current.isLoading).toBe(true);
    expect(result.current.data).toBeUndefined();

    // Wait for success
    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isSuccess).toBe(true);
    });

    expect(result.current.data).toEqual(mockTeams);
    expect(result.current.error).toBeNull();
    expect(fetchTeams).toHaveBeenCalledWith("test-access-token", "test-user-id", "Admin", null);
    expect(fetchTeams).toHaveBeenCalledTimes(1);
  });

  it("should handle error when fetchTeams fails", async () => {
    const errorMessage = "Failed to fetch teams";
    const testError = new Error(errorMessage);

    // Mock failed API call
    (fetchTeams as any).mockRejectedValue(testError);

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Initially loading
    expect(result.current.isLoading).toBe(true);

    // Wait for error
    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isError).toBe(true);
    });

    expect(result.current.error).toEqual(testError);
    expect(result.current.data).toBeUndefined();
    expect(fetchTeams).toHaveBeenCalledWith("test-access-token", "test-user-id", "Admin", null);
    expect(fetchTeams).toHaveBeenCalledTimes(1);
  });

  it("should not execute query when accessToken is missing", async () => {
    // Mock missing accessToken
    mockUseAuthorized.mockReturnValue({
      accessToken: null,
      userId: "test-user-id",
      userRole: "Admin",
      token: null,
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Query should not execute
    expect(result.current.isLoading).toBe(false);
    expect(result.current.data).toBeUndefined();
    expect(result.current.isFetched).toBe(false);

    // API should not be called
    expect(fetchTeams).not.toHaveBeenCalled();
  });

  it("should not execute query when accessToken is empty string", async () => {
    // Mock empty string accessToken
    mockUseAuthorized.mockReturnValue({
      accessToken: "",
      userId: "test-user-id",
      userRole: "Admin",
      token: "",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Query should not execute
    expect(result.current.isLoading).toBe(false);
    expect(result.current.data).toBeUndefined();
    expect(result.current.isFetched).toBe(false);

    // API should not be called
    expect(fetchTeams).not.toHaveBeenCalled();
  });

  it("should execute query when accessToken is present", async () => {
    // Mock successful API call
    (fetchTeams as any).mockResolvedValue(mockTeams);

    // Ensure auth values are set (already done in beforeEach)
    const { result } = renderHook(() => useTeams(), { wrapper });

    // Wait for query to execute
    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
    });

    expect(fetchTeams).toHaveBeenCalledWith("test-access-token", "test-user-id", "Admin", null);
    expect(fetchTeams).toHaveBeenCalledTimes(1);
  });

  it("should return empty teams array when API returns empty data", async () => {
    // Mock API returning empty teams array
    (fetchTeams as any).mockResolvedValue([]);

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Wait for success
    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isSuccess).toBe(true);
    });

    expect(result.current.data).toEqual([]);
    expect(fetchTeams).toHaveBeenCalledWith("test-access-token", "test-user-id", "Admin", null);
  });

  it("should handle network timeout error", async () => {
    const timeoutError = new Error("Network timeout");

    // Mock network timeout
    (fetchTeams as any).mockRejectedValue(timeoutError);

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Wait for error
    await waitFor(() => {
      expect(result.current.isError).toBe(true);
    });

    expect(result.current.error).toEqual(timeoutError);
    expect(result.current.data).toBeUndefined();
  });

  it("should pass userId and userRole to fetchTeams", async () => {
    // Mock successful API call
    (fetchTeams as any).mockResolvedValue(mockTeams);

    // Mock specific userId and userRole
    mockUseAuthorized.mockReturnValue({
      accessToken: "test-access-token",
      userId: "custom-user-id",
      userRole: "member",
      token: "test-token",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Wait for query to execute
    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
    });

    expect(fetchTeams).toHaveBeenCalledWith("test-access-token", "custom-user-id", "member", null);
  });

  it("should handle null userId", async () => {
    // Mock successful API call
    (fetchTeams as any).mockResolvedValue(mockTeams);

    // Mock null userId
    mockUseAuthorized.mockReturnValue({
      accessToken: "test-access-token",
      userId: null,
      userRole: "Admin",
      token: "test-token",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const { result } = renderHook(() => useTeams(), { wrapper });

    // Wait for query to execute
    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
    });

    expect(fetchTeams).toHaveBeenCalledWith("test-access-token", null, "Admin", null);
  });
});

describe("useTeam", () => {
  let queryClient: QueryClient;

  beforeEach(() => {
    queryClient = new QueryClient({
      defaultOptions: {
        queries: {
          retry: false,
        },
      },
    });

    vi.clearAllMocks();

    mockUseAuthorized.mockReturnValue({
      accessToken: "test-access-token",
      userId: "test-user-id",
      userRole: "Admin",
      token: "test-token",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });
  });

  const wrapper = ({ children }: { children: ReactNode }) =>
    React.createElement(QueryClientProvider, { client: queryClient }, children);

  it("should render", () => {
    (teamInfoCall as any).mockResolvedValue(mockTeams[0]);

    const { result } = renderHook(() => useTeam("team-1"), { wrapper });

    expect(result.current).toBeDefined();
  });

  it("should return team data when query is successful", async () => {
    (teamInfoCall as any).mockResolvedValue(mockTeams[0]);

    const { result } = renderHook(() => useTeam("team-1"), { wrapper });

    expect(result.current.isLoading).toBe(true);
    expect(result.current.data).toBeUndefined();

    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isSuccess).toBe(true);
    });

    expect(result.current.data).toEqual(mockTeams[0]);
    expect(result.current.error).toBeNull();
    expect(teamInfoCall).toHaveBeenCalledWith("test-access-token", "team-1");
    expect(teamInfoCall).toHaveBeenCalledTimes(1);
  });

  it("should handle error when teamInfoCall fails", async () => {
    const errorMessage = "Failed to fetch team";
    const testError = new Error(errorMessage);

    (teamInfoCall as any).mockRejectedValue(testError);

    const { result } = renderHook(() => useTeam("team-1"), { wrapper });

    expect(result.current.isLoading).toBe(true);

    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isError).toBe(true);
    });

    expect(result.current.error).toEqual(testError);
    expect(result.current.data).toBeUndefined();
    expect(teamInfoCall).toHaveBeenCalledWith("test-access-token", "team-1");
    expect(teamInfoCall).toHaveBeenCalledTimes(1);
  });

  it("should not execute query when accessToken is missing", () => {
    mockUseAuthorized.mockReturnValue({
      accessToken: null,
      userId: "test-user-id",
      userRole: "Admin",
      token: null,
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const { result } = renderHook(() => useTeam("team-1"), { wrapper });

    expect(result.current.isLoading).toBe(false);
    expect(result.current.data).toBeUndefined();
    expect(result.current.isFetched).toBe(false);
    expect(teamInfoCall).not.toHaveBeenCalled();
  });

  it("should not execute query when teamId is missing", () => {
    const { result } = renderHook(() => useTeam(undefined), { wrapper });

    expect(result.current.isLoading).toBe(false);
    expect(result.current.data).toBeUndefined();
    expect(result.current.isFetched).toBe(false);
    expect(teamInfoCall).not.toHaveBeenCalled();
  });

  it("should use initialData from teams list cache when available", async () => {
    queryClient.setQueryData(["teams", "list", { params: {} }], mockTeams);

    const { result } = renderHook(() => useTeam("team-1"), { wrapper });

    expect(result.current.data).toEqual(mockTeams[0]);
    // When initialData is present, isLoading is false but isFetching is true
    expect(result.current.isLoading).toBe(false);
    expect(result.current.isFetching).toBe(true);

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

  it("should return undefined initialData when teamId is not in cache", () => {
    queryClient.setQueryData(["teams", "list", { params: {} }], mockTeams);

    const { result } = renderHook(() => useTeam("non-existent-team"), { wrapper });

    expect(result.current.data).toBeUndefined();
  });

  it("should throw error in queryFn when accessToken or teamId is missing (defensive check)", async () => {
    // This tests the defensive error path in queryFn (lines 111-112)
    // The enabled check prevents queryFn from running, but we can test the defensive code
    // by manually constructing and calling the queryFn logic
    
    // Set up mocks
    mockUseAuthorized.mockReturnValue({
      accessToken: null, // Missing accessToken
      userId: "test-user-id",
      userRole: "Admin",
      token: null,
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    // Import useQueryClient to get access to query client
    const { useQueryClient } = await import("@tanstack/react-query");
    
    // Manually test the queryFn logic by calling it directly
    // This simulates what would happen if enabled check was bypassed
    const testQueryFn = async () => {
      const { accessToken } = mockUseAuthorized();
      const teamId = "team-1";
      
      // This is the defensive check from lines 111-112
      if (!accessToken || !teamId) {
        throw new Error("Missing auth or teamId");
      }
      
      return teamInfoCall(accessToken, teamId);
    };

    // Test that the error is thrown
    await expect(testQueryFn()).rejects.toThrow("Missing auth or teamId");
    
    // Also test with missing teamId
    mockUseAuthorized.mockReturnValue({
      accessToken: "test-access-token",
      userId: "test-user-id",
      userRole: "Admin",
      token: "test-token",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const testQueryFnMissingTeamId = async () => {
      const { accessToken } = mockUseAuthorized();
      const teamId = undefined; // Missing teamId
      
      if (!accessToken || !teamId) {
        throw new Error("Missing auth or teamId");
      }
      
      return teamInfoCall(accessToken, teamId);
    };

    await expect(testQueryFnMissingTeamId()).rejects.toThrow("Missing auth or teamId");
  });
});

describe("teamListCall", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    global.fetch = vi.fn();
  });

  it("should successfully fetch teams list", async () => {
    const mockResponse = {
      teams: mockTeams,
      total: 2,
      page: 1,
      page_size: 10,
      total_pages: 1,
    };

    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => mockResponse,
    });

    const result = await teamListCall("test-access-token", 1, 10, {});

    expect(result).toEqual(mockResponse);
    expect(global.fetch).toHaveBeenCalledWith(
      "/v2/team/list?page=1&page_size=10",
      expect.objectContaining({
        method: "GET",
        headers: expect.objectContaining({
          Authorization: "Bearer test-access-token",
          "Content-Type": "application/json",
        }),
      }),
    );
  });

  it("should include query parameters when options are provided", async () => {
    const mockResponse = { teams: mockTeams };

    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => mockResponse,
    });

    const options = {
      organizationID: "org-1",
      teamID: "team-1",
      team_alias: "Test Team",
      userID: "user-1",
      sortBy: "created_at",
      sortOrder: "desc",
    };

    await teamListCall("test-access-token", 1, 10, options);

    const callUrl = (global.fetch as any).mock.calls[0][0];
    expect(callUrl).toContain("organization_id=org-1");
    expect(callUrl).toContain("team_id=team-1");
    expect(callUrl).toContain("team_alias=Test+Team"); // URL encoding converts spaces to +
    expect(callUrl).toContain("user_id=user-1");
    expect(callUrl).toContain("sort_by=created_at");
    expect(callUrl).toContain("sort_order=desc");
    expect(callUrl).toContain("page=1");
    expect(callUrl).toContain("page_size=10");
  });

  it("should filter out null and undefined parameters", async () => {
    const mockResponse = { teams: mockTeams };

    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => mockResponse,
    });

    const options = {
      organizationID: null,
      teamID: undefined,
      userID: "user-1",
    };

    await teamListCall("test-access-token", 1, 10, options);

    const callUrl = (global.fetch as any).mock.calls[0][0];
    expect(callUrl).not.toContain("organization_id");
    expect(callUrl).not.toContain("team_id");
    expect(callUrl).toContain("user_id=user-1");
  });

  it("should use baseUrl when provided", async () => {
    const { getProxyBaseUrl } = await import("@/components/networking");
    (getProxyBaseUrl as any).mockReturnValue("https://api.example.com");

    const mockResponse = { teams: mockTeams };

    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => mockResponse,
    });

    await teamListCall("test-access-token", 1, 10, {});

    const callUrl = (global.fetch as any).mock.calls[0][0];
    expect(callUrl).toBe("https://api.example.com/v2/team/list?page=1&page_size=10");
  });

  it("should handle error response", async () => {
    const errorData = { error: "Failed to fetch teams" };
    (global.fetch as any).mockResolvedValue({
      ok: false,
      json: async () => errorData,
    });

    await expect(teamListCall("test-access-token", 1, 10, {})).rejects.toThrow("Failed to fetch teams");
  });

  it("should handle network errors", async () => {
    const networkError = new Error("Network error");
    (global.fetch as any).mockRejectedValue(networkError);

    await expect(teamListCall("test-access-token", 1, 10, {})).rejects.toThrow("Network error");
  });

  it("should handle error when response.json() fails", async () => {
    (global.fetch as any).mockResolvedValue({
      ok: false,
      json: async () => {
        throw new Error("Invalid JSON");
      },
    });

    await expect(teamListCall("test-access-token", 1, 10, {})).rejects.toThrow();
  });
});

describe("useDeletedTeams", () => {
  let queryClient: QueryClient;

  const mockDeletedTeams: DeletedTeam[] = [
    {
      ...mockTeams[0],
      deleted_at: "2024-01-10T00:00:00Z",
      deleted_by: "admin-user",
    },
    {
      ...mockTeams[1],
      deleted_at: "2024-01-11T00:00:00Z",
      deleted_by: "admin-user",
    },
  ];

  beforeEach(() => {
    queryClient = new QueryClient({
      defaultOptions: {
        queries: {
          retry: false,
        },
      },
    });

    vi.clearAllMocks();

    mockUseAuthorized.mockReturnValue({
      accessToken: "test-access-token",
      userId: "test-user-id",
      userRole: "Admin",
      token: "test-token",
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    global.fetch = vi.fn();
  });

  const wrapper = ({ children }: { children: ReactNode }) =>
    React.createElement(QueryClientProvider, { client: queryClient }, children);

  it("should render", () => {
    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => ({ teams: mockDeletedTeams }),
    });

    const { result } = renderHook(() => useDeletedTeams(1, 10, {}), { wrapper });

    expect(result.current).toBeDefined();
  });

  it("should return deleted teams data when query is successful", async () => {
    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => ({ teams: mockDeletedTeams }),
    });

    const { result } = renderHook(() => useDeletedTeams(1, 10, {}), { wrapper });

    expect(result.current.isLoading).toBe(true);
    expect(result.current.data).toBeUndefined();

    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isSuccess).toBe(true);
    });

    expect(result.current.data).toEqual(mockDeletedTeams);
    expect(result.current.error).toBeNull();
  });

  it("should handle error when API call fails", async () => {
    (global.fetch as any).mockResolvedValue({
      ok: false,
      json: async () => ({ error: "Failed to fetch deleted teams" }),
    });

    const { result } = renderHook(() => useDeletedTeams(1, 10, {}), { wrapper });

    expect(result.current.isLoading).toBe(true);

    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isError).toBe(true);
    });

    expect(result.current.error).toBeDefined();
    expect(result.current.data).toBeUndefined();
  });

  it("should not execute query when accessToken is missing", () => {
    mockUseAuthorized.mockReturnValue({
      accessToken: null,
      userId: "test-user-id",
      userRole: "Admin",
      token: null,
      userEmail: "test@example.com",
      premiumUser: false,
      disabledPersonalKeyCreation: null,
      showSSOBanner: false,
    });

    const { result } = renderHook(() => useDeletedTeams(1, 10, {}), { wrapper });

    expect(result.current.isLoading).toBe(false);
    expect(result.current.data).toBeUndefined();
    expect(result.current.isFetched).toBe(false);
    expect(global.fetch).not.toHaveBeenCalled();
  });

  it("should use placeholderData when paginating", async () => {
    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => ({ teams: mockDeletedTeams }),
    });

    const { result, rerender } = renderHook(
      ({ page }) => useDeletedTeams(page, 10, {}),
      {
        wrapper,
        initialProps: { page: 1 },
      },
    );

    await waitFor(() => {
      expect(result.current.isSuccess).toBe(true);
    });

    rerender({ page: 2 });

    expect(result.current.data).toEqual(mockDeletedTeams);
  });

  it("should pass options to API call", async () => {
    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => ({ teams: mockDeletedTeams }),
    });

    const options = {
      organizationID: "org-1",
      teamID: "team-1",
      userID: "user-1",
    };

    renderHook(() => useDeletedTeams(1, 10, options), { wrapper });

    await waitFor(() => {
      expect(global.fetch).toHaveBeenCalled();
    });

    const callUrl = (global.fetch as any).mock.calls[0][0];
    expect(callUrl).toContain("organization_id=org-1");
    expect(callUrl).toContain("team_id=team-1");
    expect(callUrl).toContain("user_id=user-1");
    expect(callUrl).toContain("status=deleted");
  });

  it("should handle response when data is directly an array (not wrapped in teams property)", async () => {
    (global.fetch as any).mockResolvedValue({
      ok: true,
      json: async () => mockDeletedTeams, // Direct array, not wrapped in { teams: ... }
    });

    const { result } = renderHook(() => useDeletedTeams(1, 10, {}), { wrapper });

    await waitFor(() => {
      expect(result.current.isLoading).toBe(false);
      expect(result.current.isSuccess).toBe(true);
    });

    expect(result.current.data).toEqual(mockDeletedTeams);
    expect(result.current.error).toBeNull();
  });
});