import express from 'express';
import fs from 'node:fs';
import path from 'node:path';
import dotenv from 'dotenv';
import multer from 'multer';
import { GoogleGenAI } from '@google/genai';

dotenv.config({ path: '.env.local' });
dotenv.config();

type InlineInput = {
  name?: string;
  mimeType?: string;
  data?: string;
  base64?: string;
  dataUrl?: string;
  url?: string;
};

type GenerateRequest = {
  apiKey?: string;
  prompt?: string;
  instruction?: string;
  model?: string;
  imageSize?: '1K' | '2K' | '4K';
  aspectRatio?: '1:1' | '4:3' | '3:4' | '16:9' | '9:16';
  images?: InlineInput[];
  documents?: InlineInput[];
  files?: InlineInput[];
};

type GeminiPart = {
  text?: string;
  inlineData?: {
    data: string;
    mimeType: string;
  };
};

const app = express();
const upload = multer({
  storage: multer.memoryStorage(),
  limits: {
    fileSize: Number(process.env.API_MAX_FILE_MB || 25) * 1024 * 1024,
    files: Number(process.env.API_MAX_FILES || 20),
  },
});

let runtimeApiKey = process.env.GEMINI_API_KEY || process.env.API_KEY || '';
const apiPort = Number(process.env.API_PORT || 3002);
const defaultImageModel = process.env.GEMINI_IMAGE_MODEL || 'gemini-3.1-flash-image-preview';
const defaultTextModel = process.env.GEMINI_TEXT_MODEL || 'gemini-2.5-flash';
const apiAuthToken = process.env.API_AUTH_TOKEN || '';
const apiAuthDisabled = process.env.API_AUTH_DISABLED === 'true';

if (!runtimeApiKey) {
  console.warn('GEMINI_API_KEY/API_KEY is not set. API calls will fail until it is configured.');
}

app.use((req, res, next) => {
  res.setHeader('Access-Control-Allow-Origin', process.env.API_CORS_ORIGIN || '*');
  res.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
  res.setHeader('Access-Control-Allow-Headers', 'Content-Type,Authorization,x-api-key,x-gemini-api-key');
  if (req.method === 'OPTIONS') {
    res.status(204).end();
    return;
  }
  next();
});

app.use(express.json({ limit: process.env.API_JSON_LIMIT || '50mb' }));

function requireAuth(req: express.Request, res: express.Response, next: express.NextFunction) {
  if (apiAuthDisabled) {
    next();
    return;
  }

  if (!apiAuthToken) {
    res.status(503).json({
      ok: false,
      error: 'API_AUTH_TOKEN is required. Set it in .env.local, or set API_AUTH_DISABLED=true for local-only development.',
    });
    return;
  }

  const authHeader = req.header('authorization') || '';
  const bearerToken = authHeader.startsWith('Bearer ') ? authHeader.slice(7) : '';
  const headerToken = req.header('x-api-key') || '';

  if (bearerToken === apiAuthToken || headerToken === apiAuthToken) {
    next();
    return;
  }

  res.status(401).json({
    ok: false,
    error: 'Unauthorized. Send Authorization: Bearer YOUR_API_AUTH_TOKEN or x-api-key.',
  });
}

function getRequestApiKey(req: express.Request, body?: GenerateRequest) {
  const headerKey = req.header('x-gemini-api-key') || '';
  return body?.apiKey || headerKey || runtimeApiKey;
}

function persistApiKeyToEnvLocal(apiKey: string) {
  const envPath = path.resolve(process.cwd(), '.env.local');
  let content = '';
  if (fs.existsSync(envPath)) {
    content = fs.readFileSync(envPath, 'utf8');
  }

  const escaped = apiKey.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
  const line = `GEMINI_API_KEY="${escaped}"`;
  if (/^GEMINI_API_KEY=.*$/m.test(content)) {
    content = content.replace(/^GEMINI_API_KEY=.*$/m, line);
  } else {
    content = content ? `${content.trimEnd()}\n${line}\n` : `${line}\n`;
  }

  fs.writeFileSync(envPath, content, 'utf8');
}

function stripDataPrefix(value: string) {
  const match = value.match(/^data:([^;]+);base64,(.+)$/);
  if (!match) {
    return null;
  }
  return {
    mimeType: match[1],
    data: match[2],
  };
}

async function fetchAsBase64(url: string) {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`Failed to fetch ${url}: ${response.status} ${response.statusText}`);
  }

  const contentLength = Number(response.headers.get('content-length') || 0);
  const maxBytes = Number(process.env.API_MAX_URL_MB || 25) * 1024 * 1024;
  if (contentLength > maxBytes) {
    throw new Error(`Remote file is too large. Max size is ${process.env.API_MAX_URL_MB || 25}MB.`);
  }

  const buffer = Buffer.from(await response.arrayBuffer());
  if (buffer.length > maxBytes) {
    throw new Error(`Remote file is too large. Max size is ${process.env.API_MAX_URL_MB || 25}MB.`);
  }

  return {
    data: buffer.toString('base64'),
    mimeType: response.headers.get('content-type')?.split(';')[0] || 'application/octet-stream',
  };
}

async function inlineInputToPart(input: InlineInput): Promise<GeminiPart> {
  if (input.dataUrl) {
    const parsed = stripDataPrefix(input.dataUrl);
    if (!parsed) {
      throw new Error(`Invalid dataUrl${input.name ? ` for ${input.name}` : ''}.`);
    }
    return {
      inlineData: {
        data: parsed.data,
        mimeType: input.mimeType || parsed.mimeType,
      },
    };
  }

  if (input.url) {
    const fetched = await fetchAsBase64(input.url);
    return {
      inlineData: {
        data: fetched.data,
        mimeType: input.mimeType || fetched.mimeType,
      },
    };
  }

  const rawData = input.base64 || input.data;
  if (!rawData) {
    throw new Error(`File input${input.name ? ` ${input.name}` : ''} is missing data, base64, dataUrl, or url.`);
  }

  const parsed = stripDataPrefix(rawData);
  return {
    inlineData: {
      data: parsed?.data || rawData,
      mimeType: input.mimeType || parsed?.mimeType || 'application/octet-stream',
    },
  };
}

function uploadedFileToPart(file: Express.Multer.File): GeminiPart {
  return {
    inlineData: {
      data: file.buffer.toString('base64'),
      mimeType: inferMimeType(file),
    },
  };
}

function normalizeTextInput(value: unknown) {
  if (typeof value === 'string') {
    return value;
  }

  if (Array.isArray(value)) {
    return value.map((item) => normalizeTextInput(item)).join('\n');
  }

  if (value && typeof value === 'object' && 'value' in value) {
    return normalizeTextInput((value as { value: unknown }).value);
  }

  return value == null ? '' : String(value);
}

function inferMimeType(file: Express.Multer.File) {
  if (file.mimetype && file.mimetype !== 'application/octet-stream') {
    return file.mimetype;
  }

  const ext = path.extname(file.originalname || '').toLowerCase();
  const mimeByExt: Record<string, string> = {
    '.png': 'image/png',
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.webp': 'image/webp',
    '.gif': 'image/gif',
    '.pdf': 'application/pdf',
    '.txt': 'text/plain',
    '.md': 'text/plain',
    '.csv': 'text/csv',
    '.json': 'application/json',
    '.html': 'text/html',
    '.htm': 'text/html',
  };

  return mimeByExt[ext] || 'application/octet-stream';
}

async function buildParts(body: GenerateRequest, files: Express.Multer.File[] = []) {
  const prompt = normalizeTextInput(body.prompt || body.instruction).trim();
  if (!prompt) {
    throw new Error('prompt or instruction is required.');
  }

  const inlineInputs = [
    ...(body.images || []),
    ...(body.documents || []),
    ...(body.files || []),
  ];

  const parts: GeminiPart[] = [];
  for (const input of inlineInputs) {
    parts.push(await inlineInputToPart(input));
  }

  for (const file of files) {
    parts.push(uploadedFileToPart(file));
  }

  parts.push({ text: prompt });
  return parts;
}

function normalizeMultipartBody(req: express.Request): GenerateRequest {
  return {
    apiKey: req.body.apiKey,
    prompt: String(req.body.prompt || req.body.instruction || ''),
    model: req.body.model,
    imageSize: req.body.imageSize,
    aspectRatio: req.body.aspectRatio,
  };
}

function collectResponseParts(response: any) {
  const images: Array<{ mimeType: string; data: string; dataUrl: string }> = [];
  const texts: string[] = [];

  for (const candidate of response.candidates || []) {
    for (const part of candidate.content?.parts || []) {
      if (part.inlineData?.data) {
        const mimeType = part.inlineData.mimeType || 'image/png';
        images.push({
          mimeType,
          data: part.inlineData.data,
          dataUrl: `data:${mimeType};base64,${part.inlineData.data}`,
        });
      }
      if (part.text) {
        texts.push(part.text);
      }
    }
  }

  return { images, texts };
}

async function runGemini(req: express.Request, body: GenerateRequest, files: Express.Multer.File[] = [], textOnly = false) {
  const parts = await buildParts(body, files);
  const requestApiKey = getRequestApiKey(req, body);
  if (!requestApiKey) {
    throw new Error('Gemini API key is required. Set GEMINI_API_KEY, call POST /api/config/api-key, or send x-gemini-api-key.');
  }

  const ai = new GoogleGenAI({ apiKey: requestApiKey });
  const model = body.model || (textOnly ? defaultTextModel : defaultImageModel);
  const config: Record<string, unknown> = {};

  if (!textOnly) {
    config.imageConfig = {
      imageSize: body.imageSize || '1K',
      aspectRatio: body.aspectRatio || '1:1',
    };
  }

  const response = await ai.models.generateContent({
    model,
    contents: { parts } as any,
    config,
  } as any);

  const { images, texts } = collectResponseParts(response);

  return {
    ok: true,
    model,
    usedRequestApiKey: Boolean(body.apiKey || req.header('x-gemini-api-key')),
    input: {
      fileCount: files.length + (body.images?.length || 0) + (body.documents?.length || 0) + (body.files?.length || 0),
      partCount: parts.length,
      imageSize: textOnly ? undefined : body.imageSize || '1K',
      aspectRatio: textOnly ? undefined : body.aspectRatio || '1:1',
    },
    images,
    texts,
    usageMetadata: response.usageMetadata,
  };
}

function handleError(res: express.Response, error: unknown) {
  const message = error instanceof Error ? error.message : String(error);
  res.status(400).json({
    ok: false,
    error: message,
  });
}

app.get('/api', (_req, res) => {
  res.json({
    ok: true,
    name: 'Gemini Draw API',
    endpoints: [
      'GET /api/health',
      'GET /api/config',
      'POST /api/config/api-key',
      'POST /api/generate',
      'POST /api/generate/upload',
      'POST /api/edit-image',
      'POST /api/analyze-document',
    ],
  });
});

app.get('/api/health', (_req, res) => {
  res.json({
    ok: true,
    apiPort,
    hasGeminiApiKey: Boolean(runtimeApiKey),
    authEnabled: Boolean(apiAuthToken) && !apiAuthDisabled,
    authRequired: !apiAuthDisabled,
    acceptsPerRequestApiKey: true,
    defaultImageModel,
    defaultTextModel,
  });
});

app.get('/api/config', requireAuth, (_req, res) => {
  res.json({
    ok: true,
    apiPort,
    hasGeminiApiKey: Boolean(runtimeApiKey),
    apiKeyPreview: runtimeApiKey ? `${runtimeApiKey.slice(0, 6)}...${runtimeApiKey.slice(-4)}` : '',
    authEnabled: Boolean(apiAuthToken) && !apiAuthDisabled,
    authRequired: !apiAuthDisabled,
    defaultImageModel,
    defaultTextModel,
  });
});

app.post('/api/config/api-key', requireAuth, async (req, res) => {
  try {
    const nextApiKey = String(req.body.apiKey || '').trim();
    const persist = Boolean(req.body.persist);
    if (!nextApiKey) {
      throw new Error('apiKey is required.');
    }

    runtimeApiKey = nextApiKey;
    process.env.GEMINI_API_KEY = nextApiKey;
    if (persist) {
      persistApiKeyToEnvLocal(nextApiKey);
    }

    res.json({
      ok: true,
      persisted: persist,
      apiKeyPreview: `${runtimeApiKey.slice(0, 6)}...${runtimeApiKey.slice(-4)}`,
    });
  } catch (error) {
    handleError(res, error);
  }
});

app.post('/api/generate', requireAuth, async (req, res) => {
  try {
    res.json(await runGemini(req, req.body));
  } catch (error) {
    handleError(res, error);
  }
});

app.post('/api/generate/upload', requireAuth, upload.any(), async (req, res) => {
  try {
    res.json(await runGemini(req, normalizeMultipartBody(req), (req.files as Express.Multer.File[]) || []));
  } catch (error) {
    handleError(res, error);
  }
});

app.post('/api/edit-image', requireAuth, upload.any(), async (req, res) => {
  try {
    const files = (req.files as Express.Multer.File[]) || [];
    const body = req.is('multipart/form-data') ? normalizeMultipartBody(req) : req.body;
    res.json(await runGemini(req, body, files));
  } catch (error) {
    handleError(res, error);
  }
});

app.post('/api/analyze-document', requireAuth, upload.any(), async (req, res) => {
  try {
    const files = (req.files as Express.Multer.File[]) || [];
    const body = req.is('multipart/form-data') ? normalizeMultipartBody(req) : req.body;
    res.json(await runGemini(req, body, files, true));
  } catch (error) {
    handleError(res, error);
  }
});

app.listen(apiPort, '0.0.0.0', () => {
  console.log(`Gemini Draw API listening on http://localhost:${apiPort}`);
});