import type {
  Part, HistoryItem, MessageRole, ChatSession, Language, TgUser,
  GeminiFunctionCall, GeminiResponse, Env,
} from './types';
import {
  cfg, API_URL, logger,
} from './state';
import type { LogEntry } from './types';
import {
  fetchWithTimeout, withTimeout, sleep,
  stripCodeFences, sanitizeHistoryForGemini, detectRole,
  isOwner, isKeyDisabled, disableApiKey, saveSession,
  arrayBufferToBase64, bytesToArrayBuffer,
  sendPhoto, sendAnimation, sendMessage,
  getActivePrompt, t,
} from './core';

// eslint-disable-next-line @typescript-eslint/no-explicit-any
let _toolsCache: any = { user: null, admin: null };
let _cfAccountIndex = 0;
let _elevenLabsKeyIndex = 0;

// ─────────────────────────────────────────────
// SECTION: GEMINI FUNCTION DECLARATIONS
// ─────────────────────────────────────────────

const NOVA_TOOL_DECLARATIONS = [
  {
    name: "generate_image",
    description: "Generates a high-quality image from a detailed English prompt. Use only when the user explicitly requests to create, draw, generate, or paint an image.",
    parameters: {
      type: "OBJECT",
      properties: {
        prompt: { type: "STRING", description: "Highly detailed description of the image in English." },
      },
      required: ["prompt"],
    },
  },
  {
    name: "set_persona",
    description: "Changes Nova's personality, behavior, or custom prompt/system prompt for this conversation.",
    parameters: {
      type: "OBJECT",
      properties: {
        persona: { type: "STRING", description: "Detailed description of the new persona or system prompt." },
      },
      required: ["persona"],
    },
  },
  {
    name: "search_images",
    description: "Searches Google for images. Use only when the user wants to search, find, or get images/photos from the web.",
    parameters: {
      type: "OBJECT",
      properties: {
        query: { type: "STRING", description: "Search query for images." },
      },
      required: ["query"],
    },
  },
  {
    name: "web_search",
    description: "Searches Google for web results, latest news, weather, or real-time text information.",
    parameters: {
      type: "OBJECT",
      properties: {
        query: { type: "STRING", description: "Search query for Google Web Search." },
      },
      required: ["query"],
    },
  },
  {
    name: "download_file",
    description: "Downloads songs, music, audio files, or documents from the web. Use ONLY when the user asks to download, find, or play a file, music track, or document.",
    parameters: {
      type: "OBJECT",
      properties: {
        type: { type: "STRING", enum: ["audio", "document"], description: "Type of file: 'audio' for music/songs, 'document' for other files like pdf, zip." },
        query: { type: "STRING", description: "The name of the file or song to search and download." },
      },
      required: ["type", "query"],
    },
  },
  {
    name: "create_pdf",
    description: "Generates and sends a PDF document to the user. Use only when the user explicitly requests a PDF file.",
    parameters: {
      type: "OBJECT",
      properties: {
        content: { type: "STRING", description: "The text content to put into the PDF document." },
      },
      required: ["content"],
    },
  },
  {
    name: "create_code_file",
    description: "Creates and sends a download link for a code file (e.g., Python, HTML, TypeScript, CSS) with the exact code.",
    parameters: {
      type: "OBJECT",
      properties: {
        extension: { type: "STRING", description: "File extension (e.g., py, ts, html, css, js, txt)." },
        code: { type: "STRING", description: "Full complete runnable source code with no extra markdown or comments outside code blocks." },
        filename: { type: "STRING", description: "File name without extension." },
      },
      required: ["extension", "code", "filename"],
    },
  },
  {
    name: "voice_response",
    description: "Generates high-quality speech and responds with a Telegram voice message. Use when the user sends a voice message or explicitly requests a voice/spoken response.",
    parameters: {
      type: "OBJECT",
      properties: {
        text: { type: "STRING", description: "The text content to convert to voice." },
      },
      required: ["text"],
    },
  },
  {
    name: "read_web_page",
    description: "Reads and retrieves the text content from a given URL or webpage.",
    parameters: {
      type: "OBJECT",
      properties: {
        url: { type: "STRING", description: "The complete web page URL to read." },
      },
      required: ["url"],
    },
  },
  {
    name: "set_reminder",
    description: "Sets a reminder at a specific time in the future.",
    parameters: {
      type: "OBJECT",
      properties: {
        timestamp_ms: { type: "NUMBER", description: "UNIX timestamp in milliseconds when the reminder should trigger." },
        text: { type: "STRING", description: "The reminder message." },
      },
      required: ["timestamp_ms", "text"],
    },
  },
  {
    name: "list_schedules",
    description: "Lists all currently scheduled reminders and tasks.",
    parameters: { type: "OBJECT", properties: {}, required: [] },
  },
  {
    name: "delete_schedule",
    description: "Deletes a reminder or schedule by key or title.",
    parameters: {
      type: "OBJECT",
      properties: {
        key_or_title: { type: "STRING", description: "The exact key or title of the reminder to delete." },
      },
      required: ["key_or_title"],
    },
  },
];

const ADMIN_TOOL_DECLARATIONS = [
  {
    name: "send_message_to_user",
    description: "پیام مستقیم به یک کاربر خاص می‌فرستد.",
    parameters: {
      type: "OBJECT",
      properties: {
        user_id: { type: "NUMBER", description: "شناسه عددی کاربر" },
        message: { type: "STRING", description: "متن پیام" },
      },
      required: ["user_id", "message"],
    },
  },
  {
    name: "set_vip",
    description: "وضعیت VIP یک کاربر را تغییر می‌دهد.",
    parameters: {
      type: "OBJECT",
      properties: {
        user_id: { type: "NUMBER" },
        vip: { type: "BOOLEAN" },
      },
      required: ["user_id", "vip"],
    },
  },
  {
    name: "show_logs",
    description: "لاگ‌های سیستم را نشان می‌دهد.",
    parameters: { type: "OBJECT", properties: {}, required: [] },
  },
  {
    name: "show_admin_panel",
    description: "پنل مدیریت را باز می‌کند.",
    parameters: { type: "OBJECT", properties: {}, required: [] },
  },
];

// ─────────────────────────────────────────────
// SECTION: GEMINI API
// ─────────────────────────────────────────────

async function callGemini(parts: Part[], model: string, apiKey: string, history: HistoryItem[]): Promise<string> {
  const res = await callGeminiWithTools(parts, model, apiKey, history, false);
  return res.text;
}

async function callGeminiWithTools(
  parts: Part[],
  model: string,
  apiKey: string,
  history: HistoryItem[],
  isAdmin: boolean,
  systemInstruction?: string,
  currentRole: MessageRole = "user",
): Promise<GeminiResponse> {
  const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;

  const historyToSend = history;

  const expectsResponse = parts.some(p => p.functionResponse);
  const sanitizedHistory = sanitizeHistoryForGemini(historyToSend, expectsResponse);

  const contents = [...sanitizedHistory, { role: currentRole, parts }];

  if (!_toolsCache.user) _toolsCache.user = [{ functionDeclarations: NOVA_TOOL_DECLARATIONS }];
  if (!_toolsCache.admin) _toolsCache.admin = [{ functionDeclarations: [...NOVA_TOOL_DECLARATIONS, ...ADMIN_TOOL_DECLARATIONS] }];

  const tools = isAdmin ? _toolsCache.admin : _toolsCache.user;

  const body: Record<string, unknown> = {
    contents,
    tools,
    tool_config: { function_calling_config: { mode: "AUTO" } },
    generationConfig: {
      temperature: 0.4,
      topK: 40,
      topP: 0.95,
      maxOutputTokens: 8192,
    },
    safetySettings: [
      { category: "HARM_CATEGORY_HARASSMENT",        threshold: "BLOCK_NONE" },
      { category: "HARM_CATEGORY_HATE_SPEECH",       threshold: "BLOCK_NONE" },
      { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "BLOCK_NONE" },
      { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "BLOCK_NONE" },
    ],
  };

  if (systemInstruction) {
    body.system_instruction = {
      parts: [{ text: systemInstruction }]
    };
  }

  const res = await fetchWithTimeout(url, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(body),
  }, 18_000);

  const data = await res.json() as {
    error?: { message: string; code?: number };
    candidates?: Array<{
      finishReason?: string;
      content?: {
        parts?: Array<{
          text?: string;
          thoughtSignature?: string;
          functionCall?: { name: string; args: Record<string, unknown> };
        }>;
      };
    }>;
  };

  if (data.error) {
    const msg = data.error.message.toLowerCase();
    if (msg.includes("quota") || msg.includes("429") || msg.includes("resource_exhausted")) {
      throw new Error("quota exceeded");
    }
    if (msg.includes("expired") || msg.includes("leaked")) throw new Error("auth: key expired/leaked");
    if (msg.includes("safety") || msg.includes("blocked")) throw new Error("blocked by safety filter");
    if (msg.includes("401") || msg.includes("unauthorized")) throw new Error("auth: unauthorized");
    throw new Error(`Gemini: ${data.error.message}`);
  }

  const candidate = data.candidates?.[0];
  if (candidate?.finishReason === "SAFETY") throw new Error("blocked by safety filter");

  const responseParts = candidate?.content?.parts ?? [];
  const texts: string[] = [];
  const functionCalls: GeminiFunctionCall[] = [];
  const modelPartsToSave: Part[] = [];

  for (const part of responseParts) {
    const savedPart: Part = {};
    if (part.text) {
      texts.push(part.text.trim());
      savedPart.text = part.text;
    }
    if (part.thoughtSignature) {
      savedPart.thoughtSignature = part.thoughtSignature;
    }
    if (part.functionCall) {
      savedPart.functionCall = {
        name: part.functionCall.name,
        args: part.functionCall.args ?? {},
      };
      functionCalls.push(savedPart.functionCall);
    }
    if (savedPart.text || savedPart.functionCall) {
      modelPartsToSave.push(savedPart);
    }
  }

  const combinedText = texts.join("\n").trim();
  if (!combinedText && functionCalls.length === 0) throw new Error("empty response");

  return { text: combinedText, functionCalls, modelParts: modelPartsToSave };
}

// ─────────────────────────────────────────────
// SECTION: GEMINI FLASH FALLBACK FOR CODE
// ─────────────────────────────────────────────

async function generateCodeWithGeminiFallback(
  description: string,
  type: "webapp" | "codefile",
  options?: { extension?: string },
): Promise<string | null> {
  const FALLBACK_MODEL = (cfg as any).GEMINI_FALLBACK_MODEL ?? "gemini-flash-latest";

  const prompt = type === "webapp"
    ? `Write a COMPLETE, stunning, fully functional single-file HTML web application for: ${description}\n\nRequirements:\n- Start with <!DOCTYPE html>\n- Embed ALL CSS in <style> and ALL JS in <script>\n- Beautiful modern UI\n- 100% working functionality\n\nReturn ONLY the raw HTML code, nothing else.`
    : `Write COMPLETE, production-ready ${options?.extension ?? ""} code for: ${description}\n\nReturn ONLY the raw code, no markdown, no explanation.`;

  for (const key of cfg.GEMINI_KEYS) {
    try {
      const result = await withTimeout(
        callGemini([{ text: prompt }], FALLBACK_MODEL, key, []),
        30_000,
        "Gemini fallback timeout",
      );
      if (result && result.length > 50) {
        logger.info(`✅ Gemini fallback code succeeded (${result.length} chars)`);
        return stripCodeFences(result);
      }
    } catch (e) {
      logger.warn(`Gemini fallback code gen failed: ${e instanceof Error ? e.message.slice(0, 60) : e}`);
    }
  }
  return null;
}

// ─────────────────────────────────────────────
// SECTION: ENGINE HANDLER (with retry logic)
// ─────────────────────────────────────────────

async function handleGeminiRequest(
  session: ChatSession,
  user: TgUser,
  parts: Part[],
  isGroup: boolean,
  env: Env,
): Promise<GeminiResponse> {
  if (!cfg.GEMINI_KEYS.length) throw new Error("Gemini keys not configured");

  const engine = session.engines.gemini;
  const systemPromptText = getActivePrompt(session, user, isGroup);

  let history: HistoryItem[] = [];
  if (isGroup) {
    const uHist = engine.userHistories.get(user.id);
    history = (uHist && uHist.length > 0) ? uHist : [];
  } else {
    history = engine.history.slice(2);
  }

  const isAdmin = isOwner(user.id);
  const maxAttempts = Math.min(cfg.GEMINI_KEYS.length, 5);
  let lastError: Error = new Error("quota exceeded");

  const startIdx = engine.apiKeyIndex;

  for (let i = 0; i < maxAttempts; i++) {
    const idx = (startIdx + i) % cfg.GEMINI_KEYS.length;
    const key = cfg.GEMINI_KEYS[idx];

    if (await isKeyDisabled(key, env)) {
      logger.info(`Key[${idx}] disabled, skipping`);
      continue;
    }

    try {
      const currentRole = detectRole(parts);

      const res = await withTimeout(
        callGeminiWithTools(parts, cfg.GEMINI_MODEL, key, history, isAdmin, systemPromptText, currentRole),
        22_000,
        "timeout",
      );
      engine.apiKeyIndex = idx;
      engine.consecutiveErrors = 0;
      return res;
    } catch (e) {
      lastError = e instanceof Error ? e : new Error(String(e));
      const msg = lastError.message.toLowerCase();
      logger.warn(`Key[${idx}] failed: ${msg.slice(0, 50)}`);

      if (msg.includes("blocked")) throw lastError;
      if (msg.includes("quota") || msg.includes("rate limit") || msg.includes("resource_exhausted")) {
        disableApiKey(key, env);
      }
      if (msg.includes("auth") || msg.includes("401") || msg.includes("403")) {
        disableApiKey(key, env, true);
      }
    }
  }
  engine.consecutiveErrors++;
  throw lastError;
}

// ─────────────────────────────────────────────
// SECTION: TRANSLATION
// ─────────────────────────────────────────────

async function translateToEnglish(text: string, env: Env): Promise<string> {
  if (!/[\u0600-\u06FF]/.test(text)) return text;
  const hasPersian = (s: string) => /[\u0600-\u06FF]/.test(s);
  const sys = "Translate Persian text to a concise English image prompt. Max 30 words. Output ONLY English.";

  if (cfg.GEMINI_KEYS.length) {
    try {
      const res = await callGemini([{ text: `${sys}\n\nText: ${text}` }], cfg.GEMINI_MODEL, cfg.GEMINI_KEYS[0], []);
      if (res && !hasPersian(res) && res.length > 5) return res.trim();
    } catch (e) {
      logger.warn('translateToEnglish: Gemini translation failed, falling back to strip', e);
    }
  }

  const clean = text.replace(/[\u0600-\u06FF]/g, "").trim();
  return clean.length > 3 ? clean : "A high-quality detailed artistic image";
}

// ─────────────────────────────────────────────
// SECTION: CLOUDFLARE AI IMAGE
// ─────────────────────────────────────────────

async function generateImageCF(
  prompt: string,
  model: string,
  env: Env,
): Promise<Uint8Array | null> {
  if (!cfg.CF_ACCOUNTS.length) {
    logger.warn("No Cloudflare accounts configured");
    return null;
  }

  const maxAttempts = cfg.CF_ACCOUNTS.length;
  const errors: string[] = [];

  for (let i = 0; i < maxAttempts; i++) {
    const idx = (_cfAccountIndex + i) % cfg.CF_ACCOUNTS.length;
    const account = cfg.CF_ACCOUNTS[idx];
    const url = `https://api.cloudflare.com/client/v4/accounts/${account.id}/ai/run/${model}`;

    try {
      const formData = new FormData();
      formData.append("prompt", prompt);

      const res = await fetchWithTimeout(url, {
        method: "POST",
        headers: {
          "Authorization": `Bearer ${account.token}`,
        },
        body: formData,
      }, 30_000);

      if (!res.ok) {
        const errText = await res.text().catch((e: unknown) => {
          logger.warn('generateImageCF: failed to read error body', e);
          return "";
        });
        logger.warn(`CF account[${idx}] error ${res.status}: ${errText}`);

        try {
          const parsed = JSON.parse(errText);
          const hasFlagged = parsed.errors?.some((e: any) =>
            e.code === 3030 ||
            String(e.message).toLowerCase().includes("flagged") ||
            String(e.message).toLowerCase().includes("sensitive") ||
            String(e.message).toLowerCase().includes("safety")
          );
          if (hasFlagged) {
            throw new Error("FLAGGED_PROMPT: Content flagged by safety filter.");
          }
        } catch (jsonErr) {
          if (jsonErr instanceof Error && jsonErr.message.startsWith("FLAGGED_PROMPT")) {
            throw jsonErr;
          }
        }

        throw new Error(`CF_API [HTTP ${res.status}]: ${errText || "No body response"}`);
      }

      _cfAccountIndex = idx;

      const ct = res.headers.get("content-type") ?? "";
      if (ct.includes("image/")) {
        return new Uint8Array(await res.arrayBuffer());
      }

      const json = await res.json() as any;
      if (json?.errors?.length) {
        const hasFlagged = json.errors?.some((e: any) =>
          e.code === 3030 ||
          String(e.message).toLowerCase().includes("flagged") ||
          String(e.message).toLowerCase().includes("sensitive")
        );
        if (hasFlagged) {
          throw new Error("FLAGGED_PROMPT: Content flagged by safety filter.");
        }
        throw new Error(`CF_Error: ${json.errors[0]?.message || "API Error"}`);
      }

      const b64 = json?.result?.image ?? json?.image ?? json?.result ?? json?.data?.[0]?.b64_json;
      if (!b64) {
        throw new Error("No image data in JSON response");
      }

      const bin = atob(b64);
      const bytes = new Uint8Array(bin.length);
      for (let j = 0; j < bin.length; j++) bytes[j] = bin.charCodeAt(j);
      return bytes;

    } catch (e) {
      const errMsg = e instanceof Error ? e.message : String(e);
      logger.warn(`CF account[${idx}] exception: ${errMsg}`);

      if (errMsg.includes("FLAGGED_PROMPT")) {
        throw e;
      }

      errors.push(`Account[${idx}] (${account.id?.slice(0, 6)}...): ${errMsg}`);
      continue;
    }
  }

  throw new Error(`All CF accounts failed for image generation:\n${errors.join("\n")}`);
}

function getShortModelName(path: string): string {
  const map: Record<string, string> = {
    "@cf/black-forest-labs/flux-2-klein-4b": "Flux 2 Klein 4B",
    "@cf/black-forest-labs/flux-1-schnell":  "Flux 1 Schnell",
    "@cf/leonardo/phoenix-1.0":              "Phoenix 1.0",
  };
  return map[path] ?? path.split("/").pop() ?? path;
}

// ─────────────────────────────────────────────
// SECTION: ELEVENLABS TTS
// ─────────────────────────────────────────────

async function synthesizeVoice(
  text: string,
  voiceId?: string,
): Promise<Uint8Array | null> {
  if (!cfg.ELEVENLABS_KEYS.length) return null;

  const vid = voiceId ?? cfg.ELEVENLABS_VOICE_ID;
  const maxAttempts = cfg.ELEVENLABS_KEYS.length;

  for (let i = 0; i < maxAttempts; i++) {
    const idx = (_elevenLabsKeyIndex + i) % cfg.ELEVENLABS_KEYS.length;
    const key = cfg.ELEVENLABS_KEYS[idx];

    try {
      const url = `https://api.elevenlabs.io/v1/text-to-speech/${vid}?output_format=mp3_44100_128`;

      const res = await fetchWithTimeout(
        url,
        {
          method: "POST",
          headers: {
            "xi-api-key": key,
            "Content-Type": "application/json",
            Accept: "audio/mpeg",
          },
          body: JSON.stringify({
            text: text.slice(0, 2500),
            model_id: "eleven_multilingual_v2",
            voice_settings: {
              stability: 0.5,
              similarity_boost: 0.75,
              style: 0.0,
              use_speaker_boost: true,
            },
          }),
        },
        30_000,
      );

      if (res.status === 429) {
        logger.warn(`ElevenLabs key[${idx}] rate limited (429), trying next`);
        _elevenLabsKeyIndex = (idx + 1) % cfg.ELEVENLABS_KEYS.length;
        continue;
      }

      if (res.status === 401 || res.status === 403) {
        logger.warn(`ElevenLabs key[${idx}] unauthorized (${res.status}) — key likely expired`);
        _elevenLabsKeyIndex = (idx + 1) % cfg.ELEVENLABS_KEYS.length;
        continue;
      }

      if (!res.ok) {
        const errBody = await res.text().catch((e: unknown) => {
          logger.warn('synthesizeVoice: failed to read error body', e);
          return "";
        });
        logger.warn(`ElevenLabs key[${idx}] error ${res.status}: ${errBody.slice(0, 100)}`);
        continue;
      }

      _elevenLabsKeyIndex = idx;
      const buf = await res.arrayBuffer();
      if (buf.byteLength < 100) {
        logger.warn(`ElevenLabs key[${idx}]: received empty audio`);
        continue;
      }
      return new Uint8Array(buf);

    } catch (e) {
      logger.warn(`ElevenLabs key[${idx}]: ${e instanceof Error ? e.message : e}`);
      continue;
    }
  }

  logger.error("All ElevenLabs keys failed");
  return null;
}

async function sendVoiceResponse(
  chatId: number,
  replyTo: number,
  text: string,
): Promise<boolean> {
  const audio = await synthesizeVoice(text);
  if (!audio) return false;

  const form = new FormData();
  form.append("chat_id", String(chatId));
  form.append(
    "voice",
    new Blob([bytesToArrayBuffer(audio)], { type: "audio/mpeg" }),
    "nova_voice.mp3",
  );
  form.append("reply_to_message_id", String(replyTo));

  try {
    const res = await fetchWithTimeout(
      `${API_URL}/sendVoice`,
      { method: "POST", body: form },
      20_000,
    );
    const json = await res.json() as { ok: boolean };
    return json.ok;
  } catch (e) {
    logger.warn('sendVoiceResponse: failed to send voice message', e);
    return false;
  }
}

// ─────────────────────────────────────────────
// SECTION: VOICE TRANSCRIPTION
// ─────────────────────────────────────────────

async function transcribeVoice(audioUrl: string): Promise<string> {
  for (const key of cfg.GEMINI_KEYS) {
    try {
      const audioRes = await fetchWithTimeout(audioUrl, {}, 25_000);
      const buf = await audioRes.arrayBuffer();
      const b64 = arrayBufferToBase64(buf);

      const url = `https://generativelanguage.googleapis.com/v1beta/models/${cfg.GEMINI_MODEL}:generateContent?key=${key}`;
      const res = await fetchWithTimeout(url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
          contents: [{ parts: [
            { text: "Transcribe this audio accurately to Persian or the language spoken:" },
            { inline_data: { mime_type: "audio/ogg", data: b64 } },
          ] }],
        }),
      }, 30_000);

      const data = await res.json() as {
        error?: { code?: number };
        candidates?: Array<{ content?: { parts?: Array<{ text?: string }> } }>;
      };

      if (res.ok && data.candidates?.[0]?.content?.parts?.[0]?.text) {
        return data.candidates[0].content.parts[0].text.trim();
      }
      if (data.error?.code === 429) continue;
      throw new Error("Transcription failed");
    } catch (e) {
      logger.warn('transcribeVoice: attempt failed, trying next key', e);
      continue;
    }
  }
  throw new Error("All transcription attempts failed");
}

// ─────────────────────────────────────────────
// SECTION: GOOGLE IMAGE SEARCH
// ─────────────────────────────────────────────

async function searchGoogleImages(query: string, count = 5): Promise<string[]> {
  if (!cfg.GOOGLE_SEARCH_API_KEY || !cfg.GOOGLE_SEARCH_ENGINE_ID) {
    throw new Error("Google Search not configured");
  }
  const isGif = /gif|گیف/.test(query.toLowerCase());
  const results: string[] = [];

  for (let attempt = 0; attempt < 3 && results.length < count; attempt++) {
    const url = new URL("https://www.googleapis.com/customsearch/v1");
    Object.entries({
      key: cfg.GOOGLE_SEARCH_API_KEY, cx: cfg.GOOGLE_SEARCH_ENGINE_ID,
      q: query, searchType: "image", num: "10", safe: "off",
      imgSize: "xxlarge", fileType: isGif ? "gif" : "jpg",
      start: String(Math.min((Math.abs(query.charCodeAt(0) + Date.now()) % 90) + 1 + attempt * 10, 91)),
    }).forEach(([k, v]) => url.searchParams.set(k, v));

    try {
      const res = await fetchWithTimeout(url.toString(), {}, 15_000);
      const data = await res.json() as {
        error?: { message: string; code?: number };
        items?: Array<{ link: string }>;
      };
      if (data.error) {
        if (res.status === 403 || data.error.code === 429) throw new Error(data.error.message);
        continue;
      }
      const links = (data.items ?? []).map(i => i.link).filter(l => l && !results.includes(l));
      results.push(...links);
      if (results.length >= count) break;
      await sleep(1000);
    } catch (e) {
      const msg = e instanceof Error ? e.message : "";
      if (msg.includes("quota") || msg.includes("blocked") || msg.includes("403")) throw e;
    }
  }
  if (!results.length) throw new Error("NO_RESULTS");
  return results.slice(0, count);
}

async function searchGoogleWeb(query: string): Promise<string> {
  if (!cfg.GOOGLE_SEARCH_API_KEY || !cfg.GOOGLE_SEARCH_ENGINE_ID) {
    throw new Error("Google Search not configured");
  }

  const url = new URL("https://www.googleapis.com/customsearch/v1");
  url.searchParams.set("key", cfg.GOOGLE_SEARCH_API_KEY);
  url.searchParams.set("cx", cfg.GOOGLE_SEARCH_ENGINE_ID);
  url.searchParams.set("q", query);
  url.searchParams.set("num", "6");
  url.searchParams.set("gl", "ir");

  try {
    const res = await fetchWithTimeout(url.toString(), {}, 10_000);
    const data = await res.json() as {
      items?: Array<{ title: string; link: string; snippet: string; pagemap?: { metatags?: Array<{ "og:description"?: string }> } }>;
      error?: { message: string };
      searchInformation?: { totalResults: string };
    };

    if (data.error) throw new Error(data.error.message);
    if (!data.items?.length) return "No results found for this query.";

    const results = data.items.map((item, idx) => {
      const desc = item.pagemap?.metatags?.[0]?.["og:description"] ?? item.snippet ?? "";
      return `[نتیجه ${idx + 1}]
عنوان: ${item.title}
لینک: ${item.link}
خلاصه: ${desc.slice(0, 200)}`;
    }).join("\n\n---\n\n");

    const total = data.searchInformation?.totalResults ?? "?";
    return `کل نتایج: ${total}\n\n${results}`;

  } catch (e) {
    logger.error("Web search failed", e);
    throw e;
  }
}

// ─────────────────────────────────────────────
// SECTION: PDF GENERATION
// ─────────────────────────────────────────────

function wrapInHTMLTemplate(content: string): string {
  const escaped = content
    .replace(/&/g, "&amp;")
    .replace(/</g, "&lt;")
    .replace(/>/g, "&gt;")
    .replace(/"/g, "&quot;")
    .replace(/'/g, "&#039;");

  let formatted = escaped
    .replace(/^#\s+(.+)$/gm, "<h1>$1</h1>")
    .replace(/^##\s+(.+)$/gm, "<h2>$1</h2>")
    .replace(/^###\s+(.+)$/gm, "<h3>$1</h3>")
    .replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>")
    .replace(/\*(.+?)\*/g, "<em>$1</em>")
    .replace(/```([\s\S]+?)```/g, "<pre>$1</pre>")
    .replace(/`([^`]+)`/g, "<code>$1</code>")
    .replace(/^\s*[\-\*]\s+(.+)$/gm, "<li>$1</li>");

  formatted = formatted.replace(/(<li>.+?<\/li>)+/gs, "<ul>$&</ul>");

  formatted = formatted.split(/\n\n+/).map(p => {
    if (p.trim().startsWith("<h") || p.trim().startsWith("<ul") || p.trim().startsWith("<pre>")) {
      return p;
    }
    return `<p>${p.replace(/\n/g, "<br>")}</p>`;
  }).join("\n");

  return `<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <style>
    body {
      font-family: Arial, sans-serif;
      line-height: 1.6;
      color: #333;
      padding: 40px;
    }
    h1 {
      color: #1a1a2e;
      border-bottom: 2px solid #0f3460;
      padding-bottom: 10px;
      font-size: 24px;
    }
    h2 {
      color: #0f3460;
      margin-top: 20px;
      font-size: 18px;
    }
    pre {
      background: #f4f4f8;
      padding: 15px;
      border-radius: 5px;
      border-left: 4px solid #e94560;
      font-family: monospace;
      white-space: pre-wrap;
      font-size: 13px;
    }
    code {
      background: #f4f4f8;
      padding: 2px 5px;
      border-radius: 3px;
      font-family: monospace;
    }
    ul {
      padding-left: 20px;
    }
    li {
      margin-bottom: 5px;
    }
    p {
      margin-bottom: 15px;
    }
    .footer {
      margin-top: 50px;
      font-size: 12px;
      color: #777;
      text-align: center;
      border-top: 1px solid #ddd;
      padding-top: 10px;
    }
  </style>
</head>
<body>
  <div>
    ${formatted}
  </div>
  <div class="footer">
    Generated by Nova AI Assistant
  </div>
</body>
</html>`;
}

function escapePdfText(text: string): string {
  return text
    .replace(/\\/g, "\\\\")
    .replace(/\(/g, "\\(")
    .replace(/\)/g, "\\)")
    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "");
}

function stripHTMLForPdf(input: string): string {
  return input
    .replace(/<style[\s\S]*?<\/style>/gi, "")
    .replace(/<script[\s\S]*?<\/script>/gi, "")
    .replace(/<\/(h1|h2|h3|p|li|pre|div)>/gi, "\n")
    .replace(/<br\s*\/?>/gi, "\n")
    .replace(/<li>/gi, "• ")
    .replace(/<[^>]+>/g, "")
    .replace(/&lt;/g, "<")
    .replace(/&gt;/g, ">")
    .replace(/&amp;/g, "&")
    .replace(/&quot;/g, "\"")
    .replace(/&#039;/g, "'")
    .replace(/\n{3,}/g, "\n\n")
    .trim();
}

function wrapPdfLines(text: string, maxChars = 92): string[] {
  const lines: string[] = [];
  for (const raw of text.replace(/\r\n/g, "\n").split("\n")) {
    const paragraph = raw.trimEnd();
    if (!paragraph) {
      lines.push("");
      continue;
    }
    const words = paragraph.split(/\s+/);
    let line = "";
    for (const word of words) {
      if (!line) {
        line = word;
      } else if (`${line} ${word}`.length <= maxChars) {
        line += ` ${word}`;
      } else {
        lines.push(line);
        line = word;
      }
      while (line.length > maxChars) {
        lines.push(line.slice(0, maxChars));
        line = line.slice(maxChars);
      }
    }
    lines.push(line);
  }
  return lines;
}

function generateSimplePdf(textContent: string): Uint8Array {
  const normalizedText = stripHTMLForPdf(textContent) || "Nova PDF document";
  const allLines = wrapPdfLines(normalizedText);
  const linesPerPage = 45;
  const pages: string[][] = [];
  for (let i = 0; i < allLines.length; i += linesPerPage) {
    pages.push(allLines.slice(i, i + linesPerPage));
  }
  if (!pages.length) pages.push(["Nova PDF document"]);

  const objects: string[] = [];
  const fontId = 3 + pages.length * 2;
  objects.push("<< /Type /Catalog /Pages 2 0 R >>");
  objects.push(`<< /Type /Pages /Kids [${pages.map((_, i) => `${3 + i * 2} 0 R`).join(" ")}] /Count ${pages.length} >>`);

  pages.forEach((pageLines, index) => {
    const pageId = 3 + index * 2;
    const contentId = pageId + 1;
    const streamLines = [
      "BT",
      "/F1 11 Tf",
      "50 750 Td",
      "15 TL",
      ...pageLines.map(line => line ? `(${escapePdfText(line)}) Tj T*` : "T*"),
      "ET",
    ];
    const stream = streamLines.join("\n");
    objects.push(`<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Resources << /Font << /F1 ${fontId} 0 R >> >> /Contents ${contentId} 0 R >>`);
    objects.push(`<< /Length ${new TextEncoder().encode(stream).length} >>\nstream\n${stream}\nendstream`);
  });

  objects.push("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");

  const encoder = new TextEncoder();
  let pdf = "%PDF-1.4\n%Nova\n";
  const offsets = [0];
  objects.forEach((obj, index) => {
    offsets.push(encoder.encode(pdf).length);
    pdf += `${index + 1} 0 obj\n${obj}\nendobj\n`;
  });
  const xrefOffset = encoder.encode(pdf).length;
  pdf += `xref\n0 ${objects.length + 1}\n`;
  pdf += "0000000000 65535 f \n";
  for (let i = 1; i < offsets.length; i++) {
    pdf += `${String(offsets[i]).padStart(10, "0")} 00000 n \n`;
  }
  pdf += `trailer\n<< /Size ${objects.length + 1} /Root 1 0 R >>\nstartxref\n${xrefOffset}\n%%EOF`;
  return encoder.encode(pdf);
}

async function generatePDFFromHTML(htmlContent: string): Promise<Uint8Array | null> {
  try {
    return generateSimplePdf(htmlContent);
  } catch (e) {
    logger.error("PDF generation failed", e);
    return null;
  }
}

// ─────────────────────────────────────────────
// SECTION: IMAGE RESULTS SENDING
// ─────────────────────────────────────────────

async function sendImageResults(chatId: number, replyTo: number, images: string[], caption: string, lang: Language): Promise<void> {
  for (let i = 0; i < Math.min(images.length, 5); i++) {
    const img = images[i];
    const isGif = img.toLowerCase().includes(".gif");
    try {
      if (i === 0) {
        const fullCaption = t(lang, "search_results", { caption, count: String(images.length) });
        if (isGif) await sendAnimation(chatId, img, fullCaption, { reply_to_message_id: replyTo });
        else await sendPhoto(chatId, img, fullCaption, { reply_to_message_id: replyTo });
      } else {
        if (isGif) await sendAnimation(chatId, img);
        else await sendPhoto(chatId, img);
      }
      await sleep(800);
    } catch (e) {
      logger.warn('sendImageResults: failed to send image, falling back to link', e);
      if (i === 0) {
        await sendMessage(chatId, t(lang, "search_link_fallback", { link: img, count: String(images.length) }), { reply_to_message_id: replyTo });
      }
    }
  }
}

// ─────────────────────────────────────────────
// SECTION: USER MEMORY BACKGROUND
// ─────────────────────────────────────────────

async function updateUserMemoryBackground(session: ChatSession, userId: number, chatHistory: HistoryItem[], env: Env): Promise<void> {
  const recentHistory = chatHistory.slice(-6);
  if (recentHistory.length < 3) return;

  const chatSummary = recentHistory.map(h => `${h.role}: ${h.parts[0]?.text ?? ""}`).join("\n");
  const currentMem = session.userMemories.get(userId);
  if (!currentMem) return;

  const analysisPrompt = `Analyze the recent chat history between the AI and the user to update the user's permanent profile.
Current Profile:
- Personality: "${currentMem.personality}"
- Preferences: ${JSON.stringify(currentMem.preferences)}
- Topics of interest: ${JSON.stringify(currentMem.topics)}

Recent Conversation:
${chatSummary}

Task: Update the profile with new insights (if any). Be highly conservative. ONLY output a clean JSON with the keys "personality", "preferences" (array of strings, max 8), and "topics" (array of strings, max 5). Do not include markdown codeblocks or explanation.`;

  try {
    const rawRes = await callGemini([{ text: analysisPrompt }], cfg.GEMINI_MODEL, cfg.GEMINI_KEYS[0], []);
    const cleanJson = rawRes.replace(/```json/g, "").replace(/```/g, "").trim();
    const parsed = JSON.parse(cleanJson) as { personality?: string; preferences?: string[]; topics?: string[] };

    let changed = false;
    if (parsed.personality && parsed.personality !== currentMem.personality) {
      currentMem.personality = parsed.personality;
      changed = true;
    }
    if (Array.isArray(parsed.preferences)) {
      currentMem.preferences = Array.from(new Set([...currentMem.preferences, ...parsed.preferences])).slice(0, 8);
      changed = true;
    }
    if (Array.isArray(parsed.topics)) {
      currentMem.topics = Array.from(new Set([...currentMem.topics, ...parsed.topics])).slice(0, 5);
      changed = true;
    }

    if (changed) {
      currentMem.lastSeen = Date.now();
      session.userMemories.set(userId, currentMem);
      await saveSession(session, env);
      logger.info(`🧠 Long-term memory updated for user: ${userId}`);
    }
  } catch (e) {
    logger.warn("Memory background update skipped", e);
  }
}

// ─────────────────────────────────────────────
// SECTION: PROCESS MEDIA WITH GEMINI
// ─────────────────────────────────────────────

async function processMediaWithGemini(parts: Part[]): Promise<string> {
  let lastErr: Error = new Error("No keys");
  for (const key of cfg.GEMINI_KEYS) {
    try {
      return await withTimeout(callGemini(parts, cfg.GEMINI_MODEL, key, []), 55_000, "timeout");
    } catch (e) {
      lastErr = e instanceof Error ? e : new Error(String(e));
      if (lastErr.message.includes("blocked")) break;
      await sleep(1000);
    }
  }
  throw lastErr;
}

export {
  NOVA_TOOL_DECLARATIONS,
  ADMIN_TOOL_DECLARATIONS,
  callGemini,
  callGeminiWithTools,
  generateCodeWithGeminiFallback,
  handleGeminiRequest,
  translateToEnglish,
  generateImageCF,
  getShortModelName,
  synthesizeVoice,
  sendVoiceResponse,
  transcribeVoice,
  searchGoogleImages,
  searchGoogleWeb,
  wrapInHTMLTemplate,
  escapePdfText,
  stripHTMLForPdf,
  wrapPdfLines,
  generateSimplePdf,
  generatePDFFromHTML,
  sendImageResults,
  updateUserMemoryBackground,
  processMediaWithGemini,
};