import { contextBridge, ipcRenderer } from 'electron'
import type { MySqlConfig, SqlServerConfig } from '../main/types/ipc-api.types'
import type { ExtractorInput, ExtractionProgress } from '../main/types/extractor.types'
import type { CleanerInput, CleanerProgress, ExportResultItem } from '../main/types/cleaner.types'
import type { ResolverInput } from '../main/types/resolver-ipc.types'
import type { LoginRequest } from '../main/types/auth-ipc.types'
import type { UserInfo } from '../main/types/user.types'
import type {
  ValidationRequest,
  MaterialTypeRecord,
  MaterialTypeBatchRequest
} from '../main/types/validation.types'
import type { IpcResult } from '../main/types/ipc.types'
import { IPC_CHANNELS, type LogLevel } from '../shared/ipc-channels'
import type { CleanerConfig } from '../main/types/config.schema'
import type { DownloadReleaseRequest, UpdateStatus } from '../main/types/update.types'
import type { UpdateDialogCatalog } from '../main/types/update.types'

type ErpSettingsPayload = {
  erp?: {
    username?: string
    password?: string
  }
}

const processApi = {
  versions: {
    electron: process.versions.electron,
    chrome: process.versions.chrome,
    node: process.versions.node
  }
}

function invokeIpc<T = unknown>(channel: string, ...args: unknown[]): Promise<IpcResult<T>> {
  return ipcRenderer.invoke(channel, ...args).then((result: unknown) => {
    if (result && typeof result === 'object' && 'success' in (result as Record<string, unknown>)) {
      const typed = result as Record<string, unknown>
      const hasIpcShape = 'data' in typed || 'code' in typed || 'error' in typed

      if (hasIpcShape) {
        return typed as unknown as IpcResult<T>
      }

      if (typed.success === true) {
        return { success: true, data: result as T }
      }

      return {
        success: false,
        error: typeof typed.error === 'string' ? typed.error : 'IPC operation failed'
      }
    }

    return { success: true, data: result as T }
  })
}

const api = {
  process: processApi,

  file: {
    readFile: (filePath: string) => invokeIpc(IPC_CHANNELS.FILE_READ, filePath),
    writeFile: (filePath: string, content: string) =>
      invokeIpc(IPC_CHANNELS.FILE_WRITE, filePath, content),
    fileExists: (filePath: string) => invokeIpc(IPC_CHANNELS.FILE_EXISTS, filePath),
    listFiles: (dirPath: string) => invokeIpc(IPC_CHANNELS.FILE_LIST, dirPath),
    openPath: (filePath: string) => invokeIpc(IPC_CHANNELS.FILE_OPEN_PATH, filePath)
  },

  extractor: {
    runExtractor: (input: ExtractorInput): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.EXTRACTOR_RUN, input),
    onProgress: (callback: (data: ExtractionProgress) => void) => {
      const subscription = (_event: Electron.IpcRendererEvent, data: ExtractionProgress) =>
        callback(data)
      ipcRenderer.on(IPC_CHANNELS.EXTRACTOR_PROGRESS, subscription)
      return () => ipcRenderer.removeListener(IPC_CHANNELS.EXTRACTOR_PROGRESS, subscription)
    },
    onLog: (callback: (data: { level: string; message: string }) => void) => {
      const subscription = (
        _event: Electron.IpcRendererEvent,
        data: { level: string; message: string }
      ) => callback(data)
      ipcRenderer.on(IPC_CHANNELS.EXTRACTOR_LOG, subscription)
      return () => ipcRenderer.removeListener(IPC_CHANNELS.EXTRACTOR_LOG, subscription)
    }
  },

  cleaner: {
    runCleaner: (input: CleanerInput): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.CLEANER_RUN, input),
    exportResults: (items: ExportResultItem[]): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.CLEANER_EXPORT_RESULTS, items),
    onProgress: (callback: (data: CleanerProgress) => void) => {
      const subscription = (_event: Electron.IpcRendererEvent, data: CleanerProgress) =>
        callback(data)
      ipcRenderer.on(IPC_CHANNELS.CLEANER_PROGRESS, subscription)
      return () => ipcRenderer.removeListener(IPC_CHANNELS.CLEANER_PROGRESS, subscription)
    }
  },

  resolver: {
    resolve: (input: ResolverInput): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.RESOLVER_RESOLVE, input),
    validateFormat: (inputs: string[]): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.RESOLVER_VALIDATE_FORMAT, inputs)
  },

  auth: {
    getComputerName: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.AUTH_GET_COMPUTER_NAME),
    silentLogin: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.AUTH_SILENT_LOGIN),
    login: (request: LoginRequest): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.AUTH_LOGIN, request),
    logout: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.AUTH_LOGOUT),
    getCurrentUser: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.AUTH_GET_CURRENT_USER),
    getAllUsers: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.AUTH_GET_ALL_USERS),
    switchUser: (userInfo: UserInfo): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.AUTH_SWITCH_USER, userInfo),
    isAdmin: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.AUTH_IS_ADMIN)
  },

  database: {
    connectMySql: (config: MySqlConfig): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.DATABASE_MYSQL_CONNECT, config),
    disconnectMySql: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.DATABASE_MYSQL_DISCONNECT),
    isMySqlConnected: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.DATABASE_MYSQL_IS_CONNECTED),
    queryMySql: (sql: string, params?: any[]): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.DATABASE_MYSQL_QUERY, sql, params),
    connectSqlServer: (config: SqlServerConfig): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.DATABASE_SQLSERVER_CONNECT, config),
    disconnectSqlServer: (): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.DATABASE_SQLSERVER_DISCONNECT),
    isSqlServerConnected: (): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.DATABASE_SQLSERVER_IS_CONNECTED),
    querySqlServer: (sql: string, params?: Record<string, unknown>): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.DATABASE_SQLSERVER_QUERY, sql, params)
  },

  validation: {
    validate: (request: ValidationRequest): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.VALIDATION_VALIDATE, request),
    setSharedProductionIds: (productionIds: string[]): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.VALIDATION_SET_SHARED_PRODUCTION_IDS, productionIds),
    getSharedProductionIds: (): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.VALIDATION_GET_SHARED_PRODUCTION_IDS),
    clearSharedProductionIds: (): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.VALIDATION_CLEAR_SHARED_PRODUCTION_IDS),
    getCleanerData: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.VALIDATION_GET_CLEANER_DATA)
  },

  materials: {
    upsertBatch: (materials: { materialCode: string; managerName: string }[]): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIALS_UPSERT_BATCH, { materials }),
    delete: (materialCodes: string[]): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIALS_DELETE, { materialCodes }),
    getManagers: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.MATERIALS_GET_MANAGERS),
    getByManager: (managerName: string): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIALS_GET_BY_MANAGER, managerName),
    getAll: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.MATERIALS_GET_ALL),
    getStatistics: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.MATERIALS_GET_STATISTICS),
    updateManager: (materialCode: string, managerName: string): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIALS_UPDATE_MANAGER, { materialCode, managerName })
  },

  settings: {
    getUserType: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.SETTINGS_GET_USER_TYPE),
    getSettings: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.SETTINGS_GET_SETTINGS),
    saveSettings: (settings: ErpSettingsPayload): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.SETTINGS_SAVE_SETTINGS, settings),
    resetDefaults: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.SETTINGS_RESET_DEFAULTS),
    testDbConnection: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.SETTINGS_TEST_DB_CONNECTION)
  },

  materialType: {
    getAll: (): Promise<IpcResult<MaterialTypeRecord[]>> =>
      invokeIpc(IPC_CHANNELS.MATERIAL_TYPE_GET_ALL),
    getByManager: (managerName: string): Promise<IpcResult<MaterialTypeRecord[]>> =>
      invokeIpc(IPC_CHANNELS.MATERIAL_TYPE_GET_BY_MANAGER, managerName),
    getManagers: (): Promise<IpcResult<string[]>> =>
      invokeIpc(IPC_CHANNELS.MATERIAL_TYPE_GET_MANAGERS),
    upsert: (materialName: string, managerName: string): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIAL_TYPE_UPSERT, { materialName, managerName }),
    delete: (materialName: string, managerName: string): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIAL_TYPE_DELETE, { materialName, managerName }),
    upsertBatch: (request: MaterialTypeBatchRequest): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.MATERIAL_TYPE_UPSERT_BATCH, request)
  },

  userErpConfig: {
    getCurrent: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.USER_ERP_CONFIG_GET_CURRENT),
    update: (config: { url: string; username: string; password: string }): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.USER_ERP_CONFIG_UPDATE, config),
    testConnection: (config: {
      url: string
      username: string
      password: string
    }): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.USER_ERP_CONFIG_TEST_CONNECTION, config),
    getAll: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.USER_ERP_CONFIG_GET_ALL)
  },

  config: {
    getCleaner: (): Promise<IpcResult<CleanerConfig>> => invokeIpc(IPC_CHANNELS.CONFIG_GET_CLEANER),
    updateCleaner: (updates: Partial<CleanerConfig>): Promise<IpcResult<CleanerConfig>> =>
      invokeIpc(IPC_CHANNELS.CONFIG_UPDATE_CLEANER, updates)
  },

  logger: {
    log: (level: LogLevel, message: string, context?: Record<string, unknown>): void => {
      ipcRenderer.send(IPC_CHANNELS.LOGGER_FORWARD, {
        level,
        message,
        context,
        timestamp: Date.now()
      })
    }
  },

  report: {
    listAll: (): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.REPORT_LIST_ALL),
    listByUser: (username: string): Promise<IpcResult> =>
      invokeIpc(IPC_CHANNELS.REPORT_LIST_BY_USER, username),
    download: (key: string): Promise<IpcResult> => invokeIpc(IPC_CHANNELS.REPORT_DOWNLOAD, key)
  },

  update: {
    getStatus: (): Promise<IpcResult<UpdateStatus>> => invokeIpc(IPC_CHANNELS.UPDATE_GET_STATUS),
    checkNow: (): Promise<IpcResult<UpdateStatus>> => invokeIpc(IPC_CHANNELS.UPDATE_CHECK_NOW),
    getCatalog: (): Promise<IpcResult<UpdateDialogCatalog>> =>
      invokeIpc(IPC_CHANNELS.UPDATE_GET_CATALOG),
    getChangelog: (release: DownloadReleaseRequest): Promise<IpcResult<string>> =>
      invokeIpc(IPC_CHANNELS.UPDATE_GET_CHANGELOG, release),
    downloadRelease: (release: DownloadReleaseRequest): Promise<IpcResult<UpdateStatus>> =>
      invokeIpc(IPC_CHANNELS.UPDATE_DOWNLOAD_RELEASE, release),
    installDownloaded: (): Promise<IpcResult<void>> =>
      invokeIpc(IPC_CHANNELS.UPDATE_INSTALL_DOWNLOADED),
    onStatusChanged: (callback: (data: UpdateStatus) => void) => {
      const subscription = (_event: Electron.IpcRendererEvent, data: UpdateStatus) => callback(data)
      ipcRenderer.on(IPC_CHANNELS.UPDATE_STATUS_CHANGED, subscription)
      return () => ipcRenderer.removeListener(IPC_CHANNELS.UPDATE_STATUS_CHANGED, subscription)
    }
  }
} as const

if (process.contextIsolated) {
  try {
    contextBridge.exposeInMainWorld('electron', api)
    contextBridge.exposeInMainWorld('api', api)
  } catch (error) {
    console.error(error)
  }
} else {
  // @ts-ignore (define in dts)
  window.electron = api
  // @ts-ignore (define in dts)
  window.api = api
}