/**
 * IPC Handlers
 * Bridges renderer requests to main process modules
 * Based on REQUIREMENTS.md:228-268
 */

import { ipcMain } from "electron";
import { v4 as uuidv4 } from "uuid";
import {
  saveDomain,
  getDomain,
  deleteDomain,
  listDomains,
  listVersions,
  deleteVersion,
  saveDownload,
  saveBackup,
} from "./storage";
import { SelfKintoneClient, createKintoneClient } from "./kintone-api";
import type { Result } from "@shared/types/ipc";
import type {
  CreateDomainParams,
  UpdateDomainParams,
  TestDomainConnectionParams,
  GetAppsParams,
  GetAppDetailParams,
  GetFileContentParams,
  DeployParams,
  DeployResult,
  DownloadParams,
  DownloadResult,
  GetVersionsParams,
  RollbackParams,
} from "@shared/types/ipc";
import type { Domain, DomainWithStatus, DomainWithPassword } from "@shared/types/domain";
import type {
  Version,
  DownloadMetadata,
  BackupMetadata,
} from "@shared/types/version";
import type { AppCustomizeResponse } from "@shared/types/kintone";

// Cache for Kintone clients
const clientCache = new Map<string, SelfKintoneClient>();

/**
 * Get or create a Kintone client for a domain
 */
async function getClient(domainId: string): Promise<SelfKintoneClient> {
  if (clientCache.has(domainId)) {
    return clientCache.get(domainId)!;
  }

  const domainWithPassword = await getDomain(domainId);
  if (!domainWithPassword) {
    throw new Error(`Domain not found: ${domainId}`);
  }

  const client = createKintoneClient(domainWithPassword);
  clientCache.set(domainId, client);
  return client;
}

/**
 * Helper to wrap IPC handlers with error handling
 */
function handle<T>(channel: string, handler: () => Promise<T>): void {
  ipcMain.handle(channel, async (): Promise<Result<T>> => {
    try {
      const data = await handler();
      return { success: true, data };
    } catch (error) {
      const message = error instanceof Error ? error.message : "Unknown error";
      return { success: false, error: message };
    }
  });
}

/**
 * Helper to wrap IPC handlers with parameters
 */
function handleWithParams<P, T>(
  channel: string,
  handler: (params: P) => Promise<T>,
): void {
  ipcMain.handle(channel, async (_event, params: P): Promise<Result<T>> => {
    try {
      const data = await handler(params);
      return { success: true, data };
    } catch (error) {
      const message = error instanceof Error ? error.message : "Unknown error";
      return { success: false, error: message };
    }
  });
}

// ==================== Domain Management IPC Handlers ====================

/**
 * Get all domains
 */
function registerGetDomains(): void {
  handle("getDomains", async () => {
    return listDomains();
  });
}

/**
 * Create a new domain
 * Deduplication: Check if domain+username already exists
 */
function registerCreateDomain(): void {
  handleWithParams<CreateDomainParams, Domain>(
    "createDomain",
    async (params) => {
      // Check for duplicate domain+username
      const existingDomains = await listDomains();
      const duplicate = existingDomains.find(
        (d) =>
          d.domain.toLowerCase() === params.domain.toLowerCase() &&
          d.username.toLowerCase() === params.username.toLowerCase()
      );

      if (duplicate) {
        throw new Error(
          `Domain "${params.domain}" with user "${params.username}" already exists. Please edit the existing domain instead.`
        );
      }

      const now = new Date().toISOString();
      const domain: Domain = {
        id: uuidv4(),
        name: params.name,
        domain: params.domain,
        username: params.username,
        authType: params.authType,
        apiToken: params.apiToken,
        createdAt: now,
        updatedAt: now,
      };

      await saveDomain(domain, params.password);
      return domain;
    },
  );
}

/**
 * Update an existing domain
 */
function registerUpdateDomain(): void {
  handleWithParams<UpdateDomainParams, Domain>(
    "updateDomain",
    async (params) => {
      const domains = await listDomains();
      const existing = domains.find((d) => d.id === params.id);

      if (!existing) {
        throw new Error(`Domain not found: ${params.id}`);
      }

      const updated: Domain = {
        ...existing,
        name: params.name ?? existing.name,
        domain: params.domain ?? existing.domain,
        username: params.username ?? existing.username,
        authType: params.authType ?? existing.authType,
        apiToken: params.apiToken ?? existing.apiToken,
        updatedAt: new Date().toISOString(),
      };

      // If password is provided, update it
      if (params.password) {
        await saveDomain(updated, params.password);
      } else {
        // Get existing password and re-save
        const existingWithPassword = await getDomain(params.id);
        if (existingWithPassword) {
          await saveDomain(updated, existingWithPassword.password);
        }
      }

      // Clear cached client
      clientCache.delete(params.id);

      return updated;
    },
  );
}

/**
 * Delete a domain
 */
function registerDeleteDomain(): void {
  handleWithParams<string, void>("deleteDomain", async (id) => {
    await deleteDomain(id);
    clientCache.delete(id);
  });
}

/**
 * Test domain connection
 */
function registerTestConnection(): void {
  handleWithParams<string, DomainWithStatus>("testConnection", async (id) => {
    const domainWithPassword = await getDomain(id);
    if (!domainWithPassword) {
      throw new Error(`Domain not found: ${id}`);
    }

    const client = createKintoneClient(domainWithPassword);
    const result = await client.testConnection();

    return {
      ...domainWithPassword,
      connectionStatus: result.success ? "connected" : "error",
      connectionError: result.error,
    };
  });
}

/**
 * Test domain connection with temporary credentials
 */
function registerTestDomainConnection(): void {
  handleWithParams<TestDomainConnectionParams, boolean>(
    "testDomainConnection",
    async (params) => {
      const tempDomain: DomainWithPassword = {
        id: "temp",
        name: "temp",
        domain: params.domain,
        username: params.username,
        password: params.password || "",
        authType: params.authType,
        apiToken: params.apiToken,
        createdAt: new Date().toISOString(),
        updatedAt: new Date().toISOString(),
      };

      const client = createKintoneClient(tempDomain);
      const result = await client.testConnection();

      if (!result.success) {
        throw new Error(result.error || "Connection failed");
      }

      return true;
    },
  );
}

// ==================== Browse IPC Handlers ====================

/**
 * Get apps
 */
function registerGetApps(): void {
  handleWithParams<
    GetAppsParams,
    Awaited<ReturnType<SelfKintoneClient["getApps"]>>
  >("getApps", async (params) => {
    const client = await getClient(params.domainId);
    return client.getApps({
      limit: params.limit,
      offset: params.offset,
    });
  });
}



/**
 * Get app detail
 */
function registerGetAppDetail(): void {
  handleWithParams<
    GetAppDetailParams,
    Awaited<ReturnType<SelfKintoneClient["getAppDetail"]>>
  >("getAppDetail", async (params) => {
    const client = await getClient(params.domainId);
    return client.getAppDetail(params.appId);
  });
}

/**
 * Get file content
 */
function registerGetFileContent(): void {
  handleWithParams<
    GetFileContentParams,
    Awaited<ReturnType<SelfKintoneClient["getFileContent"]>>
  >("getFileContent", async (params) => {
    const client = await getClient(params.domainId);
    return client.getFileContent(params.fileKey);
  });
}

// ==================== Deploy IPC Handlers ====================

/**
 * Deploy files to Kintone
 */
function registerDeploy(): void {
  handleWithParams<DeployParams, DeployResult>("deploy", async (params) => {
    const client = await getClient(params.domainId);
    const domainWithPassword = await getDomain(params.domainId);

    if (!domainWithPassword) {
      throw new Error(`Domain not found: ${params.domainId}`);
    }

    // Get current app config for backup
    const appDetail = await client.getAppDetail(params.appId);

    // Create backup of current configuration
    const backupFiles = new Map<string, Buffer>();
    const backupFileList: BackupMetadata["files"] = [];

    // Add JS files to backup
    for (const js of appDetail.customization?.desktop?.js || []) {
      if (js.file?.fileKey) {
        const fileContent = await client.getFileContent(js.file.fileKey);
        const content = Buffer.from(fileContent.content || "", "base64");
        backupFiles.set(`pc/${js.file.name || js.file.fileKey}.js`, content);
        backupFileList.push({
          type: "pc",
          fileType: "js",
          fileName: js.file.name || js.file.fileKey,
          fileKey: js.file.fileKey,
          size: content.length,
          path: `pc/${js.file.name || js.file.fileKey}.js`,
        });
      }
    }

    // Add CSS files to backup
    for (const css of appDetail.customization?.desktop?.css || []) {
      if (css.file?.fileKey) {
        const fileContent = await client.getFileContent(css.file.fileKey);
        const content = Buffer.from(fileContent.content || "", "base64");
        backupFiles.set(`pc/${css.file.name || css.file.fileKey}.css`, content);
        backupFileList.push({
          type: "pc",
          fileType: "css",
          fileName: css.file.name || css.file.fileKey,
          fileKey: css.file.fileKey,
          size: content.length,
          path: `pc/${css.file.name || css.file.fileKey}.css`,
        });
      }
    }
    // Save backup
    const backupMetadata: BackupMetadata = {
      backedUpAt: new Date().toISOString(),
      domain: domainWithPassword.domain,
      domainId: params.domainId,
      appId: params.appId,
      appName: appDetail.name,
      files: backupFileList,
      trigger: "deploy",
    };

    const backupPath = await saveBackup(backupMetadata, backupFiles);

    // Upload new files
    const uploadedFiles: Array<{
      type: "js" | "css";
      position: string;
      fileKey: string;
    }> = [];

    for (const file of params.files) {
      const fileKey = await client.uploadFile(file.content, file.fileName);

      uploadedFiles.push({
        type: file.fileType,
        position: file.position,
        fileKey: fileKey.fileKey,
      });
    }

    // Build new customization config
    // Note: This is simplified - real implementation would merge with existing config
    const newConfig: AppCustomizeResponse = {
      desktop: {
        js: uploadedFiles
          .filter((f) => f.type === "js" && f.position.startsWith("pc_"))
          .map((f) => ({
            type: "FILE" as const,
            file: { fileKey: f.fileKey },
          })),
        css: uploadedFiles
          .filter((f) => f.type === "css" && f.position === "pc_css")
          .map((f) => ({
            type: "FILE" as const,
            file: { fileKey: f.fileKey },
          })),
      },
      mobile: {
        js: uploadedFiles
          .filter((f) => f.type === "js" && f.position.startsWith("mobile_"))
          .map((f) => ({
            type: "FILE" as const,
            file: { fileKey: f.fileKey },
          })),
        css: uploadedFiles
          .filter((f) => f.type === "css" && f.position === "mobile_css")
          .map((f) => ({
            type: "FILE" as const,
            file: { fileKey: f.fileKey },
          })),
      },
      scope: "ALL",
      revision: "-1",
    };

    // Update app customization

    // Deploy the changes
    await client.deployApp(params.appId);

    return {
      success: true,
      backupPath,
      backupMetadata,
    };
  });
}

// ==================== Download IPC Handlers ====================

/**
 * Download files from Kintone
 */
function registerDownload(): void {
  handleWithParams<DownloadParams, DownloadResult>(
    "download",
    async (params) => {
      const client = await getClient(params.domainId);
      const domainWithPassword = await getDomain(params.domainId);

      if (!domainWithPassword) {
        throw new Error(`Domain not found: ${params.domainId}`);
      }

      const appDetail = await client.getAppDetail(params.appId);
      const downloadFiles = new Map<string, Buffer>();
      const downloadFileList: DownloadMetadata["files"] = [];

      // Download based on requested file types
      const fileTypes = params.fileTypes || [
        "pc_js",
        "pc_css",
        "mobile_js",
        "mobile_css",
      ];

      for (const fileType of fileTypes) {
        const files =
          fileType === "pc_js"
            ? appDetail.customization?.desktop?.js
            : fileType === "pc_css"
              ? appDetail.customization?.desktop?.css
              : fileType === "mobile_js"
                ? appDetail.customization?.mobile?.js
                : appDetail.customization?.mobile?.css;

        for (const file of files || []) {
          if (file.file?.fileKey) {
            const content = await client.getFileContent(file.file.fileKey);
            const buffer = Buffer.from(content.content || "", "base64");
            const fileName = file.file.name || file.file.fileKey;
            const type = fileType.includes("mobile") ? "mobile" : "pc";
            const ext = fileType.includes("js") ? "js" : "css";

            downloadFiles.set(`${type}/${fileName}`, buffer);
            downloadFileList.push({
              type,
              fileType: ext,
              fileName,
              fileKey: file.file.fileKey,
              size: buffer.length,
              path: `${type}/${fileName}`,
            });
          }
        }
      }

      // Save download metadata
      const metadata: DownloadMetadata = {
        downloadedAt: new Date().toISOString(),
        domain: domainWithPassword.domain,
        domainId: params.domainId,
        appId: params.appId,
        appName: appDetail.name,
        spaceId: appDetail.spaceId || "",
        spaceName: "", // Would need to fetch from space API
        files: downloadFileList,
        source: "kintone",
      };

      const path = await saveDownload(metadata, downloadFiles);

      return {
        success: true,
        path,
        metadata,
      };
    },
  );
}

// ==================== Version IPC Handlers ====================

/**
 * Get versions for an app
 */
function registerGetVersions(): void {
  handleWithParams<GetVersionsParams, Version[]>(
    "getVersions",
    async (params) => {
      return listVersions(params.domainId, params.appId);
    },
  );
}

/**
 * Delete a version
 */
function registerDeleteVersion(): void {
  handleWithParams<string, void>("deleteVersion", async (id) => {
    return deleteVersion(id);
  });
}

/**
 * Rollback to a previous version
 */
function registerRollback(): void {
  handleWithParams<RollbackParams, DeployResult>("rollback", async (_params) => {
    // This would read the version file and redeploy
    // Simplified implementation - would need full implementation
    throw new Error("Rollback not yet implemented");
  });
}

// ==================== Register All Handlers ====================

/**
 * Register all IPC handlers
 */
export function registerIpcHandlers(): void {
  // Domain management
  registerGetDomains();
  registerCreateDomain();
  registerUpdateDomain();
  registerDeleteDomain();
  registerTestConnection();
  registerTestDomainConnection();

  // Browse
  registerGetApps();
  registerGetAppDetail();
  registerGetFileContent();

  // Deploy
  registerDeploy();

  // Download
  registerDownload();

  // Version
  registerGetVersions();
  registerDeleteVersion();
  registerRollback();

  console.log("IPC handlers registered");
}