/**
 * Admin Proxies API endpoints
 * Handles proxy server management for administrators
 */

import { apiClient } from '../client';
import type {
  Proxy,
  CreateProxyRequest,
  UpdateProxyRequest,
  PaginatedResponse,
} from '@/types';

/**
 * List all proxies with pagination
 * @param page - Page number (default: 1)
 * @param pageSize - Items per page (default: 20)
 * @param filters - Optional filters
 * @returns Paginated list of proxies
 */
export async function list(
  page: number = 1,
  pageSize: number = 20,
  filters?: {
    protocol?: string;
    status?: 'active' | 'inactive';
    search?: string;
  }
): Promise<PaginatedResponse<Proxy>> {
  const { data } = await apiClient.get<PaginatedResponse<Proxy>>('/admin/proxies', {
    params: {
      page,
      page_size: pageSize,
      ...filters,
    },
  });
  return data;
}

/**
 * Get all active proxies (without pagination)
 * @returns List of all active proxies
 */
export async function getAll(): Promise<Proxy[]> {
  const { data } = await apiClient.get<Proxy[]>('/admin/proxies/all');
  return data;
}

/**
 * Get all active proxies with account count (sorted by creation time desc)
 * @returns List of all active proxies with account count
 */
export async function getAllWithCount(): Promise<Proxy[]> {
  const { data } = await apiClient.get<Proxy[]>('/admin/proxies/all', {
    params: { with_count: 'true' },
  });
  return data;
}

/**
 * Get proxy by ID
 * @param id - Proxy ID
 * @returns Proxy details
 */
export async function getById(id: number): Promise<Proxy> {
  const { data } = await apiClient.get<Proxy>(`/admin/proxies/${id}`);
  return data;
}

/**
 * Create new proxy
 * @param proxyData - Proxy data
 * @returns Created proxy
 */
export async function create(proxyData: CreateProxyRequest): Promise<Proxy> {
  const { data } = await apiClient.post<Proxy>('/admin/proxies', proxyData);
  return data;
}

/**
 * Update proxy
 * @param id - Proxy ID
 * @param updates - Fields to update
 * @returns Updated proxy
 */
export async function update(id: number, updates: UpdateProxyRequest): Promise<Proxy> {
  const { data } = await apiClient.put<Proxy>(`/admin/proxies/${id}`, updates);
  return data;
}

/**
 * Delete proxy
 * @param id - Proxy ID
 * @returns Success confirmation
 */
export async function deleteProxy(id: number): Promise<{ message: string }> {
  const { data } = await apiClient.delete<{ message: string }>(`/admin/proxies/${id}`);
  return data;
}

/**
 * Toggle proxy status
 * @param id - Proxy ID
 * @param status - New status
 * @returns Updated proxy
 */
export async function toggleStatus(
  id: number,
  status: 'active' | 'inactive'
): Promise<Proxy> {
  return update(id, { status });
}

/**
 * Test proxy connectivity
 * @param id - Proxy ID
 * @returns Test result with IP info
 */
export async function testProxy(id: number): Promise<{
  success: boolean;
  message: string;
  latency_ms?: number;
  ip_address?: string;
  city?: string;
  region?: string;
  country?: string;
}> {
  const { data } = await apiClient.post<{
    success: boolean;
    message: string;
    latency_ms?: number;
    ip_address?: string;
    city?: string;
    region?: string;
    country?: string;
  }>(`/admin/proxies/${id}/test`);
  return data;
}

/**
 * Get proxy usage statistics
 * @param id - Proxy ID
 * @returns Proxy usage statistics
 */
export async function getStats(id: number): Promise<{
  total_accounts: number;
  active_accounts: number;
  total_requests: number;
  success_rate: number;
  average_latency: number;
}> {
  const { data } = await apiClient.get<{
    total_accounts: number;
    active_accounts: number;
    total_requests: number;
    success_rate: number;
    average_latency: number;
  }>(`/admin/proxies/${id}/stats`);
  return data;
}

/**
 * Get accounts using a proxy
 * @param id - Proxy ID
 * @returns List of accounts using the proxy
 */
export async function getProxyAccounts(id: number): Promise<PaginatedResponse<any>> {
  const { data } = await apiClient.get<PaginatedResponse<any>>(
    `/admin/proxies/${id}/accounts`
  );
  return data;
}

/**
 * Batch create proxies
 * @param proxies - Array of proxy data to create
 * @returns Creation result with count of created and skipped
 */
export async function batchCreate(proxies: Array<{
  protocol: string;
  host: string;
  port: number;
  username?: string;
  password?: string;
}>): Promise<{
  created: number;
  skipped: number;
}> {
  const { data } = await apiClient.post<{
    created: number;
    skipped: number;
  }>('/admin/proxies/batch', { proxies });
  return data;
}

export const proxiesAPI = {
  list,
  getAll,
  getAllWithCount,
  getById,
  create,
  update,
  delete: deleteProxy,
  toggleStatus,
  testProxy,
  getStats,
  getProxyAccounts,
  batchCreate,
};

export default proxiesAPI;