import { createWriteStream } from 'node:fs';
import { rename, rm } from 'node:fs/promises';
import type { IncomingMessage, ServerResponse } from 'node:http';
import { randomUUID } from 'node:crypto';
import { basename, dirname, extname, join } from 'node:path';
import { Readable } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import { app, dialog, type SaveDialogOptions } from 'electron';
import {
  IMAGE_WORKSPACE_API_PATH,
  IMAGE_WORKSPACE_UNAVAILABLE_CODE,
  IMAGE_WORKSPACE_UNAVAILABLE_MESSAGE,
  type DesignAssetUploadInput,
  type DesignCreateConversationInput,
  type DesignConfirmGenerationInput,
  type DesignCreateWorkspaceInput,
  type DesignRenameWorkspaceInput,
  type DesignSubmitMessageInput,
} from '../../../shared/image-workspace';
import { DesignWorkspaceModuleError } from '../../image-workspace/module';
import type { HostApiContext } from '../context';
import {
  flushStreamingHeaders,
  parseJsonBody,
  sendJson,
  writeStreamingChunk,
} from '../route-utils';

function decodedSegments(pathname: string): string[] | null {
  const suffix = pathname.slice(IMAGE_WORKSPACE_API_PATH.length).replace(/^\/+/, '');
  if (!suffix) return [];
  try {
    return suffix.split('/').map((segment) => decodeURIComponent(segment));
  } catch {
    return null;
  }
}

function asString(value: unknown): string {
  return typeof value === 'string' ? value : '';
}

function asInteger(value: unknown): number {
  return typeof value === 'number' && Number.isInteger(value) ? value : -1;
}

function asStringArray(value: unknown): string[] {
  return Array.isArray(value) && value.every((item) => typeof item === 'string')
    ? value
    : [];
}

const DESIGN_IMAGE_UPLOAD_MIME_TYPES = new Set([
  'image/jpeg',
  'image/png',
  'image/webp',
]);
const MAX_DESIGN_IMAGE_UPLOAD_BYTES = 10 * 1024 * 1024;
const MAX_DESIGN_IMAGE_UPLOAD_BODY_BYTES = (
  Math.ceil(MAX_DESIGN_IMAGE_UPLOAD_BYTES / 3) * 4 + 16 * 1024
);

async function parseAssetUploadBody(req: IncomingMessage): Promise<Record<string, unknown>> {
  const declaredLength = Number(req.headers['content-length']);
  if (Number.isFinite(declaredLength) && declaredLength > MAX_DESIGN_IMAGE_UPLOAD_BODY_BYTES) {
    throw new DesignWorkspaceModuleError(
      413,
      'design_asset_upload_too_large',
      '图片大小需在 10 MB 以内',
    );
  }
  const chunks: Buffer[] = [];
  let receivedBytes = 0;
  for await (const chunk of req) {
    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
    receivedBytes += bytes.length;
    if (receivedBytes > MAX_DESIGN_IMAGE_UPLOAD_BODY_BYTES) {
      throw new DesignWorkspaceModuleError(
        413,
        'design_asset_upload_too_large',
        '图片大小需在 10 MB 以内',
      );
    }
    chunks.push(bytes);
  }
  try {
    const body = JSON.parse(Buffer.concat(chunks).toString('utf8')) as unknown;
    if (!body || typeof body !== 'object' || Array.isArray(body)) throw new Error();
    return body as Record<string, unknown>;
  } catch {
    throw new DesignWorkspaceModuleError(
      400,
      'design_asset_upload_invalid',
      '上传图片请求无效',
    );
  }
}

function decodeAssetUpload(
  workspaceId: string,
  body: Record<string, unknown>,
): DesignAssetUploadInput {
  const fileName = basename(asString(body.fileName).trim().replace(/\\/g, '/')).slice(0, 160);
  const mimeType = asString(body.mimeType);
  const encoded = asString(body.dataBase64);
  if (!fileName || !DESIGN_IMAGE_UPLOAD_MIME_TYPES.has(mimeType)) {
    throw new DesignWorkspaceModuleError(
      400,
      'design_asset_upload_invalid',
      '请选择 JPEG、PNG 或 WebP 图片',
    );
  }
  if (!encoded
    || encoded.length % 4 !== 0
    || encoded.length > Math.ceil(MAX_DESIGN_IMAGE_UPLOAD_BYTES / 3) * 4
    || !/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {
    throw new DesignWorkspaceModuleError(
      413,
      'design_asset_upload_too_large',
      '图片大小需在 10 MB 以内',
    );
  }
  const bytes = Buffer.from(encoded, 'base64');
  if (bytes.length <= 0 || bytes.length > MAX_DESIGN_IMAGE_UPLOAD_BYTES) {
    throw new DesignWorkspaceModuleError(
      413,
      'design_asset_upload_too_large',
      '图片大小需在 10 MB 以内',
    );
  }
  return {
    workspaceId,
    fileName,
    mimeType: mimeType as DesignAssetUploadInput['mimeType'],
    bytes,
  };
}

function sendData(res: ServerResponse, data: unknown): void {
  sendJson(res, 200, { success: true, status: 200, data });
}

const IMAGE_FILE_EXTENSIONS = new Set(['.gif', '.jpeg', '.jpg', '.png', '.svg', '.webp']);

function safeImageFileName(value: string, assetId: string): string {
  const fallbackId = assetId
    .replace(/[^a-zA-Z0-9_-]+/g, '-')
    .replace(/^-+|-+$/g, '')
    .slice(0, 32) || 'image';
  const fallback = `Makelore-AI-Design-${fallbackId}.png`;
  const sanitized = [...value.trim().replace(/[<>:"/\\|?*]/g, '-')]
    .map((character) => character.charCodeAt(0) < 32 ? '-' : character)
    .join('')
    .replace(/[. ]+$/g, '')
    .slice(0, 120);
  if (!sanitized || !IMAGE_FILE_EXTENSIONS.has(extname(sanitized).toLowerCase())) {
    return fallback;
  }
  return sanitized;
}

async function saveAssetContent(
  res: ServerResponse,
  ctx: HostApiContext,
  workspaceId: string,
  assetId: string,
  defaultFileName: string,
): Promise<void> {
  const fileName = safeImageFileName(defaultFileName, assetId);
  const extension = extname(fileName).slice(1);
  const options: SaveDialogOptions = {
    defaultPath: join(app.getPath('downloads'), fileName),
    filters: [
      { name: '图片', extensions: [extension] },
      { name: '所有文件', extensions: ['*'] },
    ],
  };
  const mainWindow = ctx.mainWindow && !ctx.mainWindow.isDestroyed()
    ? ctx.mainWindow
    : null;
  const selection = mainWindow
    ? await dialog.showSaveDialog(mainWindow, options)
    : await dialog.showSaveDialog(options);
  if (selection.canceled || !selection.filePath) {
    sendData(res, { status: 'cancelled' });
    return;
  }

  const content = await ctx.imageWorkspace!.openAssetContent(workspaceId, assetId);
  if (!content.ok || !content.body || !content.headers.get('content-type')?.startsWith('image/')) {
    throw new DesignWorkspaceModuleError(
      content.status >= 400 ? content.status : 502,
      'DESIGN_ASSET_DOWNLOAD_FAILED',
      '生成图片暂时无法下载，请稍后重试',
    );
  }

  const temporaryPath = join(
    dirname(selection.filePath),
    `.${basename(selection.filePath)}.${randomUUID()}.download`,
  );
  try {
    await pipeline(
      Readable.fromWeb(content.body),
      createWriteStream(temporaryPath, { flags: 'wx' }),
    );
    await rename(temporaryPath, selection.filePath);
  } catch {
    await rm(temporaryPath, { force: true }).catch(() => undefined);
    throw new DesignWorkspaceModuleError(
      500,
      'DESIGN_ASSET_SAVE_FAILED',
      '图片保存失败，请重新选择位置后重试',
    );
  }
  sendData(res, { status: 'saved' });
}

function sendRouteError(res: ServerResponse, error: unknown): void {
  if (res.headersSent) {
    res.destroy(error instanceof Error ? error : undefined);
    return;
  }
  if (error instanceof DesignWorkspaceModuleError) {
    sendJson(res, error.status, {
      success: false,
      status: error.status,
      code: error.code,
      error: error.message,
    });
    return;
  }
  if (error instanceof SyntaxError) {
    sendJson(res, 400, {
      success: false,
      status: 400,
      code: 'IMAGE_WORKSPACE_INVALID_JSON',
      error: '请求内容不是有效 JSON',
    });
    return;
  }
  sendJson(res, 500, {
    success: false,
    status: 500,
    code: 'IMAGE_WORKSPACE_REQUEST_FAILED',
    error: error instanceof Error ? error.message : 'AI 设计请求失败',
  });
}

async function relayAssetContent(
  req: IncomingMessage,
  res: ServerResponse,
  ctx: HostApiContext,
  workspaceId: string,
  assetId: string,
): Promise<void> {
  const content = await ctx.imageWorkspace!.openAssetContent(
    workspaceId,
    assetId,
    typeof req.headers.range === 'string' ? req.headers.range : undefined,
  );
  res.statusCode = content.status;
  for (const header of [
    'accept-ranges',
    'cache-control',
    'content-length',
    'content-range',
    'content-type',
    'etag',
    'last-modified',
  ]) {
    const value = content.headers.get(header);
    if (value) res.setHeader(header, value);
  }
  if (!content.body || req.method === 'HEAD') {
    res.end();
    return;
  }
  await pipeline(Readable.fromWeb(content.body), res);
}

async function relayWorkspaceEvents(
  req: IncomingMessage,
  res: ServerResponse,
  ctx: HostApiContext,
  workspaceId: string,
  conversationId: string,
): Promise<void> {
  if (!ctx.imageWorkspace?.openWorkspaceEvents) {
    throw new DesignWorkspaceModuleError(
      501,
      'DESIGN_EVENT_STREAM_UNAVAILABLE',
      'AI 设计任务实时状态暂时不可用',
    );
  }
  const header = req.headers['last-event-id'];
  const afterEventId = Array.isArray(header) ? header[0] : header;
  const subscription = await ctx.imageWorkspace.openWorkspaceEvents({
    workspaceId,
    conversationId,
    ...(afterEventId ? { afterEventId } : {}),
  });
  let closed = false;
  const close = () => {
    if (closed) return;
    closed = true;
    subscription.close();
  };
  res.once('close', close);
  try {
    res.statusCode = 200;
    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
    res.setHeader('Cache-Control', 'no-cache, no-transform');
    res.setHeader('Connection', 'keep-alive');
    res.setHeader('X-Accel-Buffering', 'no');
    flushStreamingHeaders(res);
    if (!await writeStreamingChunk(res, ': connected\n\n')) return;
    for await (const event of subscription.events) {
      if (!await writeStreamingChunk(
        res,
        `id: ${event.id}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`,
      )) {
        return;
      }
    }
    if (!res.writableEnded) res.end();
  } finally {
    res.off('close', close);
    close();
  }
}

export async function handleImageWorkspaceRoutes(
  req: IncomingMessage,
  res: ServerResponse,
  url: URL,
  ctx: HostApiContext,
): Promise<boolean> {
  if (url.pathname !== IMAGE_WORKSPACE_API_PATH
    && !url.pathname.startsWith(`${IMAGE_WORKSPACE_API_PATH}/`)) {
    return false;
  }

  if (!ctx.imageWorkspace) {
    sendJson(res, 501, {
      success: false,
      status: 501,
      code: IMAGE_WORKSPACE_UNAVAILABLE_CODE,
      error: IMAGE_WORKSPACE_UNAVAILABLE_MESSAGE,
    });
    return true;
  }

  const segments = decodedSegments(url.pathname);
  if (!segments) {
    sendJson(res, 400, { success: false, status: 400, error: '无效的 AI 设计路径' });
    return true;
  }

  try {
    if (segments.length === 0 && req.method === 'GET') {
      sendData(res, await ctx.imageWorkspace.bootstrap());
      return true;
    }

    if (segments.length === 1 && segments[0] === 'workspaces' && req.method === 'POST') {
      const body = await parseJsonBody<Record<string, unknown>>(req);
      const input: DesignCreateWorkspaceInput = {
        clientWorkspaceId: asString(body.clientWorkspaceId),
        title: asString(body.title),
      };
      sendData(res, await ctx.imageWorkspace.createWorkspace(input));
      return true;
    }

    if (segments.length === 1 && segments[0] === 'local-data' && req.method === 'DELETE') {
      if (!ctx.imageWorkspace.reset) {
        throw new DesignWorkspaceModuleError(
          405,
          'IMAGE_WORKSPACE_RESET_NOT_ALLOWED',
          '云端 AI 设计不支持清空本地数据',
        );
      }
      sendData(res, await ctx.imageWorkspace.reset());
      return true;
    }

    if (segments.length === 2 && segments[0] === 'workspaces' && req.method === 'GET') {
      sendData(res, await ctx.imageWorkspace.getWorkspace(segments[1]));
      return true;
    }

    if (segments.length === 2 && segments[0] === 'workspaces' && req.method === 'PATCH') {
      const body = await parseJsonBody<Record<string, unknown>>(req);
      const input: DesignRenameWorkspaceInput = {
        workspaceId: segments[1],
        title: asString(body.title),
      };
      sendData(res, await ctx.imageWorkspace.renameWorkspace(input));
      return true;
    }

    if (segments.length === 3
      && segments[0] === 'workspaces'
      && segments[2] === 'conversations'
      && req.method === 'POST') {
      const body = await parseJsonBody<Record<string, unknown>>(req);
      const input: DesignCreateConversationInput = {
        workspaceId: segments[1],
        clientConversationId: asString(body.clientConversationId),
        title: asString(body.title),
      };
      sendData(res, await ctx.imageWorkspace.createConversation(input));
      return true;
    }

    if (segments.length === 4
      && segments[0] === 'workspaces'
      && segments[2] === 'conversations'
      && req.method === 'GET') {
      sendData(res, await ctx.imageWorkspace.getConversation(segments[1], segments[3]));
      return true;
    }

    if (segments.length === 5
      && segments[0] === 'workspaces'
      && segments[2] === 'conversations'
      && segments[4] === 'messages'
      && req.method === 'POST') {
      const body = await parseJsonBody<Record<string, unknown>>(req);
      const input: DesignSubmitMessageInput = {
        workspaceId: segments[1],
        conversationId: segments[3],
        clientTurnId: asString(body.clientTurnId),
        expectedTurnRevision: asInteger(body.expectedTurnRevision),
        message: asString(body.message),
        attachmentAssetIds: asStringArray(body.attachmentAssetIds),
      };
      sendData(res, await ctx.imageWorkspace.submitMessage(input));
      return true;
    }

    if (segments.length === 3
      && segments[0] === 'workspaces'
      && segments[2] === 'tasks'
      && req.method === 'GET') {
      sendData(res, await ctx.imageWorkspace.listTasks(segments[1]));
      return true;
    }

    if (segments.length === 3
      && segments[0] === 'workspaces'
      && segments[2] === 'assets'
      && req.method === 'POST') {
      if (!ctx.imageWorkspace.uploadAsset) {
        throw new DesignWorkspaceModuleError(
          501,
          IMAGE_WORKSPACE_UNAVAILABLE_CODE,
          '当前环境暂不支持上传设计图片',
        );
      }
      const body = await parseAssetUploadBody(req);
      sendData(
        res,
        await ctx.imageWorkspace.uploadAsset(decodeAssetUpload(segments[1], body)),
      );
      return true;
    }

    if (segments.length === 5
      && segments[0] === 'workspaces'
      && segments[2] === 'conversations'
      && segments[4] === 'events'
      && req.method === 'GET') {
      await relayWorkspaceEvents(req, res, ctx, segments[1], segments[3]);
      return true;
    }

    if (segments.length === 7
      && segments[0] === 'workspaces'
      && segments[2] === 'conversations'
      && segments[4] === 'quotes'
      && segments[6] === 'confirm'
      && req.method === 'POST') {
      const body = await parseJsonBody<Record<string, unknown>>(req);
      const input: DesignConfirmGenerationInput = {
        workspaceId: segments[1],
        conversationId: segments[3],
        quoteId: segments[5],
        clientTurnId: asString(body.clientTurnId),
        expectedTurnRevision: asInteger(body.expectedTurnRevision),
      };
      sendData(res, await ctx.imageWorkspace.confirmGeneration(input));
      return true;
    }

    if (segments.length === 5
      && segments[0] === 'workspaces'
      && segments[2] === 'assets'
      && segments[4] === 'content'
      && (req.method === 'GET' || req.method === 'HEAD')) {
      await relayAssetContent(req, res, ctx, segments[1], segments[3]);
      return true;
    }

    if (segments.length === 5
      && segments[0] === 'workspaces'
      && segments[2] === 'assets'
      && segments[4] === 'download'
      && req.method === 'POST') {
      const body = await parseJsonBody<Record<string, unknown>>(req);
      await saveAssetContent(
        res,
        ctx,
        segments[1],
        segments[3],
        asString(body.defaultFileName),
      );
      return true;
    }

    sendJson(res, 404, {
      success: false,
      status: 404,
      code: 'IMAGE_WORKSPACE_ROUTE_NOT_FOUND',
      error: `没有对应的 AI 设计接口：${req.method ?? 'GET'} ${url.pathname}`,
    });
  } catch (error) {
    sendRouteError(res, error);
  }
  return true;
}