import api from './client';
import type {
  DashboardStats,
  AnalyticsData,
  AuditLog,
  ApiUser,
  PaginatedResponse,
  Organization,
  Lead,
  User,
  PlatformRole,
  CompanyRole,
  Portfolio,
  EmailCampaign,
  EmailDeliveryLog,
} from '../types';

export interface ProxyConnectorRecord {
  id: string;
  service: string;
  serviceDisplayName?: string;
  status: string;
  auth_type?: string;
  sync_frequency: string;
  last_sync_at: string | null;
  error_message: string;
  created_at: string | null;
  contacts_count?: number;
  deals_count?: number;
  sync_count?: number;
}

export interface ProxyConnectorDef {
  service: string;
  name: string;
  category: string;
  description: string;
  auth_type: string;
  auth_fields: string[];
  config_fields?: Array<{
    name: string;
    label: string;
    type: 'select' | 'text' | 'password';
    options?: string[];
    required: boolean;
  }>;
  capabilities: string[];
  rate_limit: string;
  docs_url: string;
}

// ─── Super-admin proxy helpers (manage any company's integrations) ─────────

export const proxyApi = {
  // Connectors

  listConnectors: async (companyId: string): Promise<{ connectors: ProxyConnectorRecord[] }> => {
    const { data } = await api.get(`/api/super-admin/company/${companyId}/connectors`);
    // Proxy returns {success, data: [...]} — normalize to {connectors: [...]}
    return { connectors: data?.data || [] };
  },

  availableConnectors: async (): Promise<{ connectors: ProxyConnectorDef[] }> => {
    const { data } = await api.get('/api/connectors/available');
    return data;
  },

  connectorStatus: async (companyId: string, connectorId: string): Promise<any> => {
    const { data } = await api.get(`/api/super-admin/company/${companyId}/connectors/${connectorId}/status`);
    return data;
  },

  syncConnector: async (companyId: string, connectorId: string): Promise<any> => {
    const { data } = await api.post(`/api/super-admin/company/${companyId}/connectors/${connectorId}/sync`);
    return data;
  },

  refreshConnector: async (companyId: string, connectorId: string): Promise<any> => {
    const { data } = await api.post(`/api/super-admin/company/${companyId}/connectors/${connectorId}/refresh`);
    return data;
  },

  connectorLogs: async (companyId: string, connectorId: string): Promise<any> => {
    const { data } = await api.get(`/api/super-admin/company/${companyId}/connectors/${connectorId}/logs`);
    return data;
  },

  disconnectConnector: async (companyId: string, connectorId: string): Promise<any> => {
    const { data } = await api.post(`/api/super-admin/company/${companyId}/connectors/${connectorId}/disconnect`);
    return data;
  },

  updateConnector: async (companyId: string, connectorId: string, updates: Record<string, unknown>): Promise<any> => {
    const { data } = await api.put(`/api/super-admin/company/${companyId}/connectors/${connectorId}`, updates);
    return data;
  },

  createConnector: async (companyId: string, service: string, config: Record<string, string>, sync_frequency: string = 'hourly'): Promise<any> => {
    const { data } = await api.post(`/api/super-admin/company/${companyId}/connectors`, { service, config, sync_frequency });
    return data;
  },

  // Billing

  getSubscription: async (companyId: string): Promise<any> => {
    const { data } = await api.get(`/api/super-admin/company/${companyId}/billing/subscription`);
    return data;
  },

  // Company overview

  companyOverview: async (companyId: string): Promise<any> => {
    const { data } = await api.get(`/api/super-admin/company/${companyId}/overview`);
    return data;
  },
};

export const adminApi = {
  getOverview: async (): Promise<DashboardStats> => {
    const { data } = await api.get<DashboardStats>('/api/super-admin/overview');
    return data;
  },

  getAnalytics: async (): Promise<AnalyticsData> => {
    const { data } = await api.get<AnalyticsData>('/api/super-admin/analytics');
    return data;
  },

  getOrganizations: async (): Promise<PaginatedResponse<Organization>> => {
    const { data } = await api.get<PaginatedResponse<Organization>>('/api/super-admin/organizations');
    return data;
  },

  createOrganization: async (data: {
    name: string;
    industry?: string;
    annual_revenue?: number;
    address?: string;
    city?: string;
    state?: string;
    postal_code?: string;
    country?: string;
    phone?: string;
    website?: string;
    owner_id?: string;
    stripe_customer_id?: string;
  }): Promise<{ success: boolean; organization: { id: string; name: string } }> => {
    const { data: result } = await api.post<{ success: boolean; organization: { id: string; name: string } }>('/api/super-admin/organizations', data);
    return result;
  },

  deleteOrganization: async (orgId: string): Promise<{ success: boolean; message: string }> => {
    const { data } = await api.delete<{ success: boolean; message: string }>(`/api/super-admin/organizations/${orgId}`);
    return data;
  },

  getUsers: async (params?: {
    limit?: number;
    role?: string;
  }): Promise<PaginatedResponse<ApiUser>> => {
    const { data } = await api.get<PaginatedResponse<ApiUser>>('/api/super-admin/users', { params });
    return data;
  },

  createUser: async (data: {
    email: string;
    full_name?: string;
    password: string;
    role?: PlatformRole;
    company_name?: string;
    company_role?: CompanyRole;
  }): Promise<{ success: boolean; user: ApiUser }> => {
    const { data: result } = await api.post<{ success: boolean; user: ApiUser }>('/api/super-admin/users', data);
    return result;
  },

  deleteUser: async (userId: number): Promise<{ success: boolean; message: string }> => {
    const { data } = await api.delete<{ success: boolean; message: string }>(`/api/super-admin/users/${userId}`);
    return data;
  },

  updateUserRole: async (userId: number, role: PlatformRole): Promise<User> => {
    const { data } = await api.put<{ user: User }>(`/api/super-admin/users/${userId}/role`, { role });
    return data.user;
  },

  updateCompanyRole: async (userId: number, role: CompanyRole, companyId?: number): Promise<{ id: number; email: string; full_name: string; role: string; companyRole: CompanyRole; companyId?: number }> => {
    const body: Record<string, unknown> = { role };
    if (companyId) body.company_id = companyId;
    const { data } = await api.put<{ user: { id: number; email: string; full_name: string; role: string; companyRole: CompanyRole; companyId?: number; created?: boolean } }>(`/api/super-admin/users/${userId}/company-role`, body);
    return data.user;
  },

  updateUser: async (
    userId: number,
    data: { full_name?: string; email?: string; role?: PlatformRole; is_active?: boolean },
  ): Promise<User> => {
    const { data: result } = await api.put<{ user: User }>(`/api/super-admin/users/${userId}`, data);
    return result.user;
  },

  getAuditLogs: async (params?: {
    limit?: number;
    entityType?: string;
    actorEmail?: string;
  }): Promise<PaginatedResponse<AuditLog>> => {
    const { data } = await api.get<PaginatedResponse<AuditLog>>('/api/super-admin/audit', { params });
    return data;
  },

  getGroups: async (): Promise<PaginatedResponse<unknown>> => {
    const { data } = await api.get('/api/super-admin/groups');
    return data;
  },

  getLeads: async (): Promise<PaginatedResponse<Lead>> => {
    const { data } = await api.get<PaginatedResponse<Lead>>('/api/super-admin/leads');
    return data;
  },

  getLeadRecipients: async (): Promise<{
    items: { id: string; name: string; email: string; type: string }[];
  }> => {
    const { data } = await api.get('/api/super-admin/lead-recipients');
    return data;
  },

  getEmailFailures: async (status?: string): Promise<PaginatedResponse<unknown>> => {
    const { data } = await api.get('/api/super-admin/email-failures', { params: { status } });
    return data;
  },

  // Portfolios
  getPortfolios: async (): Promise<{ items: Portfolio[]; total: number }> => {
    const { data } = await api.get('/api/portfolios/');
    return data;
  },

  getPortfolio: async (id: string): Promise<{ portfolio: Portfolio }> => {
    const { data } = await api.get(`/api/portfolios/${id}`);
    return data;
  },

  createPortfolio: async (data: { name: string; description?: string; company_ids?: string[] }): Promise<{ portfolio: Portfolio }> => {
    const { data: result } = await api.post('/api/portfolios/', data);
    return result;
  },

  updatePortfolio: async (id: string, data: { name?: string; description?: string }): Promise<{ portfolio: Portfolio }> => {
    const { data: result } = await api.put(`/api/portfolios/${id}`, data);
    return result;
  },

  deletePortfolio: async (id: string): Promise<{ message: string }> => {
    const { data } = await api.delete(`/api/portfolios/${id}`);
    return data;
  },

  addPortfolioCompanies: async (id: string, company_ids: string[]): Promise<{ portfolio: Portfolio; added: string[] }> => {
    const { data } = await api.post(`/api/portfolios/${id}/companies`, { company_ids });
    return data;
  },

  removePortfolioCompanies: async (id: string, company_ids: string[]): Promise<{ portfolio: Portfolio; removed: string[] }> => {
    const { data } = await api.delete(`/api/portfolios/${id}/companies`, { data: { company_ids } });
    return data;
  },

  // Email Campaigns
  getEmailCampaigns: async (): Promise<{ items: EmailCampaign[]; total: number }> => {
    const { data } = await api.get('/api/email-campaigns/');
    return data;
  },

  getEmailCampaign: async (id: string): Promise<{ campaign: EmailCampaign; logs: EmailDeliveryLog[] }> => {
    const { data } = await api.get(`/api/email-campaigns/${id}`);
    return data;
  },

  createEmailCampaign: async (data: {
    name: string;
    status?: string;
    subject?: string;
    body?: string;
    recipients?: { email: string }[];
  }): Promise<{ campaign: EmailCampaign }> => {
    const { data: result } = await api.post('/api/email-campaigns/', data);
    return result;
  },

  updateEmailCampaign: async (id: string, data: {
    status?: string;
    subject?: string;
    body?: string;
    total_sent?: number;
    delivered?: number;
    opened?: number;
    bounced?: number;
    failed?: number;
  }): Promise<{ campaign: EmailCampaign }> => {
    const { data: result } = await api.put(`/api/email-campaigns/${id}`, data);
    return result;
  },

  deleteEmailCampaign: async (id: string): Promise<{ message: string }> => {
    const { data } = await api.delete(`/api/email-campaigns/${id}`);
    return data;
  },

  // Partners
  getPartners: async (): Promise<{ partners: unknown[] }> => {
    const { data } = await api.get('/api/super-admin/partners');
    return data;
  },

  createPartner: async (name: string): Promise<{ partner: unknown }> => {
    const { data } = await api.post('/api/super-admin/partners', { name });
    return data;
  },
};