import axios, { AxiosInstance, AxiosRequestConfig, AxiosResponse, AxiosError } from 'axios'
import { storage } from './storage'

/**
 * API Error class for standardized error handling
 */
export class ApiError extends Error {
  public status: number
  public code: string
  public details: Record<string, unknown>

  constructor(message: string, status: number, code: string = 'UNKNOWN_ERROR', details: Record<string, unknown> = {}) {
    super(message)
    this.name = 'ApiError'
    this.status = status
    this.code = code
    this.details = details
  }

  static fromAxiosError(error: AxiosError<ApiErrorResponse>): ApiError {
    const response = error.response
    if (response?.data) {
      return new ApiError(
        response.data.message || 'An error occurred',
        response.status,
        response.data.code || 'API_ERROR',
        response.data.details || {}
      )
    }
    if (error.request) {
      return new ApiError('Network error - no response received', 0, 'NETWORK_ERROR')
    }
    return new ApiError(error.message || 'Unknown error', 0, 'UNKNOWN_ERROR')
  }
}

interface ApiErrorResponse {
  message: string
  code?: string
  details?: Record<string, unknown>
}

interface ApiSuccessResponse<T> {
  success: boolean
  data: T
  message?: string
  meta?: {
    page?: number
    per_page?: number
    total?: number
    total_pages?: number
  }
}

interface RefreshTokenResponse {
  access_token: string
  refresh_token: string
  expires_in: number
}

/**
 * API Client configuration
 */
interface ApiClientConfig {
  baseURL: string
  timeout?: number
  headers?: Record<string, string>
}

/**
 * API Client class with request/response interceptors
 */
class ApiClient {
  private client: AxiosInstance
  private refreshPromise: Promise<string> | null = null

  constructor(config: ApiClientConfig) {
    this.client = axios.create({
      baseURL: config.baseURL,
      timeout: config.timeout || 30000,
      headers: {
        'Content-Type': 'application/json',
        ...config.headers,
      },
    })

    this.setupInterceptors()
  }

  private setupInterceptors(): void {
    // Request interceptor
    this.client.interceptors.request.use(
      (config) => {
        const token = storage.get<string>('access_token')
        if (token) {
          config.headers.Authorization = `Bearer ${token}`
        }

        // Add company context header if available
        const currentCompany = storage.get<string>('current_company_id')
        if (currentCompany) {
          config.headers['X-Company-ID'] = currentCompany
        }

        return config
      },
      (error) => Promise.reject(error)
    )

    // Response interceptor
    this.client.interceptors.response.use(
      (response) => response,
      async (error: AxiosError<ApiErrorResponse>) => {
        const originalRequest = error.config as AxiosRequestConfig & { _retry?: boolean }

        // Handle 401 Unauthorized - attempt token refresh
        if (error.response?.status === 401 && !originalRequest._retry) {
          originalRequest._retry = true

          try {
            const newToken = await this.refreshAccessToken()
            storage.set('access_token', newToken)
            
            // Retry the original request with new token
            if (originalRequest.headers) {
              originalRequest.headers.Authorization = `Bearer ${newToken}`
            }
            return this.client(originalRequest)
          } catch (refreshError) {
            // Clear tokens and redirect to login
            storage.remove('access_token')
            storage.remove('refresh_token')
            window.location.href = '/login'
            return Promise.reject(ApiError.fromAxiosError(error))
          }
        }

        return Promise.reject(ApiError.fromAxiosError(error))
      }
    )
  }

  private async refreshAccessToken(): Promise<string> {
    // Prevent multiple refresh requests
    if (this.refreshPromise) {
      return this.refreshPromise
    }

    const refreshToken = storage.get<string>('refresh_token')
    if (!refreshToken) {
      throw new ApiError('No refresh token available', 401, 'NO_REFRESH_TOKEN')
    }

    this.refreshPromise = this.client
      .post<ApiSuccessResponse<RefreshTokenResponse>>('/auth/refresh', {
        refresh_token: refreshToken,
      })
      .then((response) => {
        const { access_token, refresh_token } = response.data.data
        storage.set('access_token', access_token)
        storage.set('refresh_token', refresh_token)
        return access_token
      })
      .finally(() => {
        this.refreshPromise = null
      })

    return this.refreshPromise
  }

  /**
   * GET request
   */
  async get<T>(url: string, config?: AxiosRequestConfig): Promise<ApiSuccessResponse<T>> {
    const response = await this.client.get<ApiSuccessResponse<T>>(url, config)
    return response.data
  }

  /**
   * POST request
   */
  async post<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<ApiSuccessResponse<T>> {
    const response = await this.client.post<ApiSuccessResponse<T>>(url, data, config)
    return response.data
  }

  /**
   * PUT request
   */
  async put<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<ApiSuccessResponse<T>> {
    const response = await this.client.put<ApiSuccessResponse<T>>(url, data, config)
    return response.data
  }

  /**
   * PATCH request
   */
  async patch<T>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<ApiSuccessResponse<T>> {
    const response = await this.client.patch<ApiSuccessResponse<T>>(url, data, config)
    return response.data
  }

  /**
   * DELETE request
   */
  async delete<T>(url: string, config?: AxiosRequestConfig): Promise<ApiSuccessResponse<T>> {
    const response = await this.client.delete<ApiSuccessResponse<T>>(url, config)
    return response.data
  }

  /**
   * Upload file
   */
  async upload<T>(
    url: string,
    file: File,
    fieldName: string = 'file',
    additionalData?: Record<string, string>,
    onProgress?: (progress: number) => void
  ): Promise<ApiSuccessResponse<T>> {
    const formData = new FormData()
    formData.append(fieldName, file)

    if (additionalData) {
      Object.entries(additionalData).forEach(([key, value]) => {
        formData.append(key, value)
      })
    }

    const response = await this.client.post<ApiSuccessResponse<T>>(url, formData, {
      headers: {
        'Content-Type': 'multipart/form-data',
      },
      onUploadProgress: (progressEvent) => {
        if (progressEvent.total && onProgress) {
          const progress = Math.round((progressEvent.loaded * 100) / progressEvent.total)
          onProgress(progress)
        }
      },
    })

    return response.data
  }

  /**
   * Download file
   */
  async download(
    url: string,
    filename?: string,
    config?: AxiosRequestConfig
  ): Promise<void> {
    const response = await this.client.get<Blob>(url, {
      ...config,
      responseType: 'blob',
    })

    const blob = response.data
    const downloadFilename = filename || this.extractFilename(response) || 'download'
    
    const downloadUrl = URL.createObjectURL(blob)
    const link = document.createElement('a')
    link.href = downloadUrl
    link.download = downloadFilename
    document.body.appendChild(link)
    link.click()
    document.body.removeChild(link)
    URL.revokeObjectURL(downloadUrl)
  }

  private extractFilename(response: AxiosResponse): string | null {
    const contentDisposition = response.headers['content-disposition']
    if (contentDisposition) {
      const filenameMatch = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/)
      if (filenameMatch && filenameMatch[1]) {
        return filenameMatch[1].replace(/['"]/g, '')
      }
    }
    return null
  }

  /**
   * Set base URL dynamically
   */
  setBaseURL(baseURL: string): void {
    this.client.defaults.baseURL = baseURL
  }

  /**
   * Set default header
   */
  setHeader(key: string, value: string): void {
    this.client.defaults.headers.common[key] = value
  }

  /**
   * Remove default header
   */
  removeHeader(key: string): void {
    delete this.client.defaults.headers.common[key]
  }
}

// Create singleton instance
const API_BASE_URL = process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000/api/v1'

export const apiClient = new ApiClient({
  baseURL: API_BASE_URL,
  timeout: 30000,
})

/**
 * API endpoint builders for each module
 */
export const endpoints = {
  // Auth
  auth: {
    login: '/auth/login',
    logout: '/auth/logout',
    refresh: '/auth/refresh',
    me: '/auth/me',
    password: {
      change: '/auth/password/change',
      reset: '/auth/password/reset',
      forgot: '/auth/password/forgot',
    },
    mfa: {
      enable: '/auth/mfa/enable',
      disable: '/auth/mfa/disable',
      verify: '/auth/mfa/verify',
      backup: '/auth/mfa/backup-codes',
    },
    apiKeys: {
      list: '/auth/api-keys',
      create: '/auth/api-keys',
      revoke: (id: string) => `/auth/api-keys/${id}/revoke`,
    },
  },

  // Companies
  companies: {
    list: '/companies',
    create: '/companies',
    get: (id: string) => `/companies/${id}`,
    update: (id: string) => `/companies/${id}`,
    delete: (id: string) => `/companies/${id}`,
    hierarchy: (id: string) => `/companies/${id}/hierarchy`,
    settings: (id: string) => `/companies/${id}/settings`,
    subsidiaries: (id: string) => `/companies/${id}/subsidiaries`,
    stats: (id: string) => `/companies/${id}/stats`,
  },

  // Users
  users: {
    list: '/users',
    create: '/users',
    get: (id: string) => `/users/${id}`,
    update: (id: string) => `/users/${id}`,
    delete: (id: string) => `/users/${id}`,
    profile: '/users/profile',
    preferences: '/users/preferences',
    avatar: '/users/avatar',
    password: '/users/password',
    bulk: {
      create: '/users/bulk/create',
      update: '/users/bulk/update',
      delete: '/users/bulk/delete',
    },
    permissions: (id: string) => `/users/${id}/permissions`,
  },

  // Accounts / Chart of Accounts
  accounts: {
    list: '/accounts',
    create: '/accounts',
    get: (id: string) => `/accounts/${id}`,
    update: (id: string) => `/accounts/${id}`,
    delete: (id: string) => `/accounts/${id}`,
    tree: '/accounts/tree',
    balance: (id: string) => `/accounts/${id}/balance`,
    types: '/accounts/types',
    import: '/accounts/import',
    export: '/accounts/export',
  },

  // Journal Entries
  journalEntries: {
    list: '/journal-entries',
    create: '/journal-entries',
    get: (id: string) => `/journal-entries/${id}`,
    update: (id: string) => `/journal-entries/${id}`,
    delete: (id: string) => `/journal-entries/${id}`,
    post: (id: string) => `/journal-entries/${id}/post`,
    reverse: (id: string) => `/journal-entries/${id}/reverse`,
    validate: '/journal-entries/validate',
    templates: '/journal-entries/templates',
  },

  // Fiscal Years & Periods
  fiscalYears: {
    list: '/fiscal-years',
    create: '/fiscal-years',
    get: (id: string) => `/fiscal-years/${id}`,
    update: (id: string) => `/fiscal-years/${id}`,
    close: (id: string) => `/fiscal-years/${id}/close`,
    periods: (id: string) => `/fiscal-years/${id}/periods`,
  },

  // Treasury
  treasury: {
    accounts: {
      list: '/treasury/accounts',
      create: '/treasury/accounts',
      get: (id: string) => `/treasury/accounts/${id}`,
      update: (id: string) => `/treasury/accounts/${id}`,
      delete: (id: string) => `/treasury/accounts/${id}`,
      balance: (id: string) => `/treasury/accounts/${id}/balance`,
      reconcile: (id: string) => `/treasury/accounts/${id}/reconcile`,
    },
    transactions: {
      list: '/treasury/transactions',
      create: '/treasury/transactions',
      get: (id: string) => `/treasury/transactions/${id}`,
      update: (id: string) => `/treasury/transactions/${id}`,
      delete: (id: string) => `/treasury/transactions/${id}`,
      transfer: '/treasury/transactions/transfer',
      import: '/treasury/transactions/import',
      export: '/treasury/transactions/export',
    },
    budgets: {
      list: '/treasury/budgets',
      create: '/treasury/budgets',
      get: (id: string) => `/treasury/budgets/${id}`,
      update: (id: string) => `/treasury/budgets/${id}`,
      delete: (id: string) => `/treasury/budgets/${id}`,
      actuals: (id: string) => `/treasury/budgets/${id}/actuals`,
    },
    cashFlow: {
      forecast: '/treasury/cash-flow/forecast',
      statement: '/treasury/cash-flow/statement',
    },
  },

  // Invoices
  invoices: {
    list: '/invoices',
    create: '/invoices',
    get: (id: string) => `/invoices/${id}`,
    update: (id: string) => `/invoices/${id}`,
    delete: (id: string) => `/invoices/${id}`,
    send: (id: string) => `/invoices/${id}/send`,
    void: (id: string) => `/invoices/${id}/void`,
    duplicate: (id: string) => `/invoices/${id}/duplicate`,
    pdf: (id: string) => `/invoices/${id}/pdf`,
    payments: (id: string) => `/invoices/${id}/payments`,
    credit: '/invoices/credit',
    templates: '/invoices/templates',
  },

  // Bills
  bills: {
    list: '/bills',
    create: '/bills',
    get: (id: string) => `/bills/${id}`,
    update: (id: string) => `/bills/${id}`,
    delete: (id: string) => `/bills/${id}`,
    approve: (id: string) => `/bills/${id}/approve`,
    pay: (id: string) => `/bills/${id}/pay`,
    void: (id: string) => `/bills/${id}/void`,
  },

  // Customers
  customers: {
    list: '/customers',
    create: '/customers',
    get: (id: string) => `/customers/${id}`,
    update: (id: string) => `/customers/${id}`,
    delete: (id: string) => `/customers/${id}`,
    statements: (id: string) => `/customers/${id}/statements`,
    aging: (id: string) => `/customers/${id}/aging`,
  },

  // Vendors
  vendors: {
    list: '/vendors',
    create: '/vendors',
    get: (id: string) => `/vendors/${id}`,
    update: (id: string) => `/vendors/${id}`,
    delete: (id: string) => `/vendors/${id}`,
    statements: (id: string) => `/vendors/${id}/statements`,
    aging: (id: string) => `/vendors/${id}/aging`,
  },

  // HR
  hr: {
    employees: {
      list: '/hr/employees',
      create: '/hr/employees',
      get: (id: string) => `/hr/employees/${id}`,
      update: (id: string) => `/hr/employees/${id}`,
      delete: (id: string) => `/hr/employees/${id}`,
      onboarding: (id: string) => `/hr/employees/${id}/onboarding`,
      offboarding: (id: string) => `/hr/employees/${id}/offboarding`,
      documents: (id: string) => `/hr/employees/${id}/documents`,
    },
    departments: {
      list: '/hr/departments',
      create: '/hr/departments',
      get: (id: string) => `/hr/departments/${id}`,
      update: (id: string) => `/hr/departments/${id}`,
      delete: (id: string) => `/hr/departments/${id}`,
    },
    positions: {
      list: '/hr/positions',
      create: '/hr/positions',
      get: (id: string) => `/hr/positions/${id}`,
      update: (id: string) => `/hr/positions/${id}`,
      delete: (id: string) => `/hr/positions/${id}`,
    },
    payroll: {
      list: '/hr/payroll',
      run: '/hr/payroll/run',
      get: (id: string) => `/hr/payroll/${id}`,
      approve: (id: string) => `/hr/payroll/${id}/approve`,
      payslips: (id: string) => `/hr/payroll/${id}/payslips`,
    },
    attendance: {
      list: '/hr/attendance',
      clockIn: '/hr/attendance/clock-in',
      clockOut: '/hr/attendance/clock-out',
      adjust: (id: string) => `/hr/attendance/${id}/adjust`,
    },
    leave: {
      types: '/hr/leave/types',
      requests: '/hr/leave/requests',
      approve: (id: string) => `/hr/leave/requests/${id}/approve`,
      reject: (id: string) => `/hr/leave/requests/${id}/reject`,
    },
    timeOff: {
      balance: '/hr/time-off/balance',
      request: '/hr/time-off/request',
    },
  },

  // Tax
  tax: {
    rates: {
      list: '/tax/rates',
      create: '/tax/rates',
      get: (id: string) => `/tax/rates/${id}`,
      update: (id: string) => `/tax/rates/${id}`,
      delete: (id: string) => `/tax/rates/${id}`,
    },
    jurisdictions: {
      list: '/tax/jurisdictions',
      create: '/tax/jurisdictions',
      get: (id: string) => `/tax/jurisdictions/${id}`,
    },
    nexus: {
      list: '/tax/nexus',
      create: '/tax/nexus',
      get: (id: string) => `/tax/nexus/${id}`,
      delete: (id: string) => `/tax/nexus/${id}`,
    },
    filings: {
      list: '/tax/filings',
      create: '/tax/filings',
      get: (id: string) => `/tax/filings/${id}`,
      update: (id: string) => `/tax/filings/${id}`,
      submit: (id: string) => `/tax/filings/${id}/submit`,
    },
    calculations: {
      calculate: '/tax/calculate',
      validate: '/tax/validate',
    },
    reports: {
      liability: '/tax/reports/liability',
      summary: '/tax/reports/summary',
    },
  },

  // Workflow
  workflow: {
    definitions: {
      list: '/workflow/definitions',
      create: '/workflow/definitions',
      get: (id: string) => `/workflow/definitions/${id}`,
      update: (id: string) => `/workflow/definitions/${id}`,
      delete: (id: string) => `/workflow/definitions/${id}`,
      publish: (id: string) => `/workflow/definitions/${id}/publish`,
      versions: (id: string) => `/workflow/definitions/${id}/versions`,
    },
    executions: {
      list: '/workflow/executions',
      start: '/workflow/executions/start',
      get: (id: string) => `/workflow/executions/${id}`,
      cancel: (id: string) => `/workflow/executions/${id}/cancel`,
      retry: (id: string) => `/workflow/executions/${id}/retry`,
      tasks: (id: string) => `/workflow/executions/${id}/tasks`,
      completeTask: (executionId: string, taskId: string) =>
        `/workflow/executions/${executionId}/tasks/${taskId}/complete`,
    },
    triggers: {
      list: '/workflow/triggers',
      create: '/workflow/triggers',
      get: (id: string) => `/workflow/triggers/${id}`,
      delete: (id: string) => `/workflow/triggers/${id}`,
      toggle: (id: string) => `/workflow/triggers/${id}/toggle`,
    },
  },

  // Legal
  legal: {
    contracts: {
      list: '/legal/contracts',
      create: '/legal/contracts',
      get: (id: string) => `/legal/contracts/${id}`,
      update: (id: string) => `/legal/contracts/${id}`,
      delete: (id: string) => `/legal/contracts/${id}`,
      approve: (id: string) => `/legal/contracts/${id}/approve`,
      sign: (id: string) => `/legal/contracts/${id}/sign`,
      renew: (id: string) => `/legal/contracts/${id}/renew`,
      terminate: (id: string) => `/legal/contracts/${id}/terminate`,
      amendments: (id: string) => `/legal/contracts/${id}/amendments`,
      documents: (id: string) => `/legal/contracts/${id}/documents`,
    },
    matters: {
      list: '/legal/matters',
      create: '/legal/matters',
      get: (id: string) => `/legal/matters/${id}`,
      update: (id: string) => `/legal/matters/${id}`,
      delete: (id: string) => `/legal/matters/${id}`,
      close: (id: string) => `/legal/matters/${id}/close`,
      reopen: (id: string) => `/legal/matters/${id}/reopen`,
      tasks: (id: string) => `/legal/matters/${id}/tasks`,
      timeEntries: (id: string) => `/legal/matters/${id}/time-entries`,
    },
    compliance: {
      list: '/legal/compliance',
      create: '/legal/compliance',
      get: (id: string) => `/legal/compliance/${id}`,
      update: (id: string) => `/legal/compliance/${id}`,
      review: (id: string) => `/legal/compliance/${id}/review`,
      requirements: (id: string) => `/legal/compliance/${id}/requirements`,
    },
    templates: {
      list: '/legal/templates',
      create: '/legal/templates',
      get: (id: string) => `/legal/templates/${id}`,
      update: (id: string) => `/legal/templates/${id}`,
      delete: (id: string) => `/legal/templates/${id}`,
    },
  },

  // Reports
  reports: {
    templates: {
      list: '/reports/templates',
      create: '/reports/templates',
      get: (id: string) => `/reports/templates/${id}`,
      update: (id: string) => `/reports/templates/${id}`,
      delete: (id: string) => `/reports/templates/${id}`,
      duplicate: (id: string) => `/reports/templates/${id}/duplicate`,
    },
    executions: {
      list: '/reports/executions',
      create: '/reports/executions',
      get: (id: string) => `/reports/executions/${id}`,
      cancel: (id: string) => `/reports/executions/${id}/cancel`,
      download: (id: string) => `/reports/executions/${id}/download`,
    },
    dashboards: {
      list: '/reports/dashboards',
      create: '/reports/dashboards',
      get: (id: string) => `/reports/dashboards/${id}`,
      update: (id: string) => `/reports/dashboards/${id}`,
      delete: (id: string) => `/reports/dashboards/${id}`,
      widgets: (id: string) => `/reports/dashboards/${id}/widgets`,
    },
    scheduled: {
      list: '/reports/scheduled',
      create: '/reports/scheduled',
      get: (id: string) => `/reports/scheduled/${id}`,
      update: (id: string) => `/reports/scheduled/${id}`,
      delete: (id: string) => `/reports/scheduled/${id}`,
      toggle: (id: string) => `/reports/scheduled/${id}/toggle`,
    },
    financial: {
      balanceSheet: '/reports/financial/balance-sheet',
      incomeStatement: '/reports/financial/income-statement',
      cashFlow: '/reports/financial/cash-flow',
      trialBalance: '/reports/financial/trial-balance',
      generalLedger: '/reports/financial/general-ledger',
    },
  },

  // Consolidation
  consolidation: {
    scenarios: {
      list: '/consolidation/scenarios',
      create: '/consolidation/scenarios',
      get: (id: string) => `/consolidation/scenarios/${id}`,
      update: (id: string) => `/consolidation/scenarios/${id}`,
      delete: (id: string) => `/consolidation/scenarios/${id}`,
      run: (id: string) => `/consolidation/scenarios/${id}/run`,
      results: (id: string) => `/consolidation/scenarios/${id}/results`,
    },
    eliminations: {
      list: '/consolidation/eliminations',
      create: '/consolidation/eliminations',
      get: (id: string) => `/consolidation/eliminations/${id}`,
      update: (id: string) => `/consolidation/eliminations/${id}`,
      delete: (id: string) => `/consolidation/eliminations/${id}`,
    },
    intercompany: {
      transactions: '/consolidation/intercompany/transactions',
      reconcile: '/consolidation/intercompany/reconcile',
      match: '/consolidation/intercompany/match',
    },
    mappings: {
      list: '/consolidation/mappings',
      create: '/consolidation/mappings',
      get: (id: string) => `/consolidation/mappings/${id}`,
      update: (id: string) => `/consolidation/mappings/${id}`,
      delete: (id: string) => `/consolidation/mappings/${id}`,
    },
    currency: {
      rates: '/consolidation/currency/rates',
      convert: '/consolidation/currency/convert',
    },
  },

  // Assets
  assets: {
    classes: {
      list: '/assets/classes',
      create: '/assets/classes',
      get: (id: string) => `/assets/classes/${id}`,
      update: (id: string) => `/assets/classes/${id}`,
      delete: (id: string) => `/assets/classes/${id}`,
    },
    locations: {
      list: '/assets/locations',
      create: '/assets/locations',
      get: (id: string) => `/assets/locations/${id}`,
      update: (id: string) => `/assets/locations/${id}`,
      delete: (id: string) => `/assets/locations/${id}`,
    },
    fixedAssets: {
      list: '/assets/fixed-assets',
      create: '/assets/fixed-assets',
      get: (id: string) => `/assets/fixed-assets/${id}`,
      update: (id: string) => `/assets/fixed-assets/${id}`,
      delete: (id: string) => `/assets/fixed-assets/${id}`,
      approve: (id: string) => `/assets/fixed-assets/${id}/approve`,
      transfer: (id: string) => `/assets/fixed-assets/${id}/transfer`,
      dispose: (id: string) => `/assets/fixed-assets/${id}/dispose`,
      schedule: (id: string) => `/assets/fixed-assets/${id}/schedule`,
    },
    depreciation: {
      list: '/assets/depreciation',
      run: '/assets/depreciation/run',
      get: (id: string) => `/assets/depreciation/${id}`,
      post: (id: string) => `/assets/depreciation/${id}/post`,
      reverse: (id: string) => `/assets/depreciation/${id}/reverse`,
    },
    disposals: {
      list: '/assets/disposals',
      create: '/assets/disposals',
      get: (id: string) => `/assets/disposals/${id}`,
      approve: (id: string) => `/assets/disposals/${id}/approve`,
    },
    maintenance: {
      list: '/assets/maintenance',
      create: '/assets/maintenance',
      get: (id: string) => `/assets/maintenance/${id}`,
      update: (id: string) => `/assets/maintenance/${id}`,
      complete: (id: string) => `/assets/maintenance/${id}/complete`,
    },
    insurance: {
      list: '/assets/insurance',
      create: '/assets/insurance',
      get: (id: string) => `/assets/insurance/${id}`,
      update: (id: string) => `/assets/insurance/${id}`,
    },
  },

  // AI
  ai: {
    models: {
      list: '/ai/models',
      create: '/ai/models',
      get: (id: string) => `/ai/models/${id}`,
      update: (id: string) => `/ai/models/${id}`,
      delete: (id: string) => `/ai/models/${id}`,
      train: (id: string) => `/ai/models/${id}/train`,
      deploy: (id: string) => `/ai/models/${id}/deploy`,
      predict: (id: string) => `/ai/models/${id}/predict`,
    },
    anomalies: {
      list: '/ai/anomalies',
      scan: '/ai/anomalies/scan',
      get: (id: string) => `/ai/anomalies/${id}`,
      dismiss: (id: string) => `/ai/anomalies/${id}/dismiss`,
      confirm: (id: string) => `/ai/anomalies/${id}/confirm`,
    },
    forecasts: {
      list: '/ai/forecasts',
      create: '/ai/forecasts',
      get: (id: string) => `/ai/forecasts/${id}`,
      run: (id: string) => `/ai/forecasts/${id}/run`,
    },
    insights: {
      list: '/ai/insights',
      generate: '/ai/insights/generate',
      get: (id: string) => `/ai/insights/${id}`,
      dismiss: (id: string) => `/ai/insights/${id}/dismiss`,
      act: (id: string) => `/ai/insights/${id}/act`,
    },
    recommendations: {
      list: '/ai/recommendations',
      get: (id: string) => `/ai/recommendations/${id}`,
      dismiss: (id: string) => `/ai/recommendations/${id}/dismiss`,
      apply: (id: string) => `/ai/recommendations/${id}/apply`,
    },
    commands: {
      process: '/ai/commands/process',
      history: '/ai/commands/history',
    },
    documentAnalysis: {
      analyze: '/ai/document-analysis/analyze',
      results: (id: string) => `/ai/document-analysis/${id}`,
    },
    explainability: {
      explain: '/ai/explainability/explain',
      get: (id: string) => `/ai/explainability/${id}`,
    },
  },

  // Notifications
  notifications: {
    list: '/notifications',
    unread: '/notifications/unread',
    markRead: (id: string) => `/notifications/${id}/read`,
    markAllRead: '/notifications/read-all',
    preferences: '/notifications/preferences',
    subscribe: '/notifications/subscribe',
    unsubscribe: '/notifications/unsubscribe',
  },

  // Search
  search: {
    global: '/search',
    recent: '/search/recent',
    saved: '/search/saved',
    save: '/search/save',
    delete: (id: string) => `/search/saved/${id}`,
  },

  // Audit Log
  audit: {
    log: '/audit/log',
    entity: (entityType: string, entityId: string) => `/audit/${entityType}/${entityId}`,
    export: '/audit/export',
  },
} as const

export type Endpoints = typeof endpoints