/* eslint-disable @typescript-eslint/no-explicit-any */

import * as cheerio from 'cheerio';
import { nanoid } from 'nanoid';

import { db } from '@/lib/db';

const SOURCE_SCRIPT_REGISTRY_KEY = 'source-script:registry';
const MAX_HISTORY_ITEMS = 10;
const DEFAULT_TIMEOUT_MS = 20000;

export interface SourceScriptVersion {
  version: string;
  code: string;
  updatedAt: number;
}

export interface SourceScriptRecord {
  id: string;
  key: string;
  name: string;
  description?: string;
  enabled: boolean;
  version: string;
  code: string;
  createdAt: number;
  updatedAt: number;
  history: SourceScriptVersion[];
}

export interface SourceScriptImportItem {
  key: string;
  name: string;
  description?: string;
  code: string;
  enabled?: boolean;
}

export interface SourceScriptRegistry {
  items: SourceScriptRecord[];
}

export interface SourceScriptTestResult {
  ok: boolean;
  durationMs: number;
  logs: string[];
  meta?: Record<string, any>;
  result?: any;
  error?: string;
}

export type SourceScriptHook =
  | 'getSources'
  | 'search'
  | 'recommend'
  | 'detail'
  | 'resolvePlayUrl';

export interface PublicSourceScriptSummary {
  id: string;
  key: string;
  name: string;
  description?: string;
  version: string;
  updatedAt: number;
}

export interface ScriptSourceDescriptor {
  id: string;
  name: string;
}

const SCRIPT_SOURCE_PREFIX = 'script:';
const SCRIPT_EPISODE_PREFIX = '__script_ep__';

const DEFAULT_SCRIPT_TEMPLATE = `return {
  meta: {
    name: '示例脚本',
    author: 'admin'
  },

  async getSources(ctx) {
    return [
      { id: 'main', name: '主站' },
      { id: 'backup', name: '备用站' }
    ];
  },

  async search(ctx, { keyword, page, sourceId }) {
    ctx.log.info('search', keyword, page, sourceId);
    return {
      sourceId,
      list: [],
      page,
      pageCount: 1,
      total: 0
    };
  },

  async recommend(ctx, { page }) {
    ctx.log.info('recommend', page);
    return {
      list: [],
      page: page || 1,
      pageCount: 1,
      total: 0
    };
  },

  async detail(ctx, { id, sourceId }) {
    ctx.log.info('detail', id, sourceId);
    return {
      id,
      sourceId,
      title: '',
      poster: '',
      year: '',
      desc: '',
      playbacks: [
        {
          sourceId: sourceId || 'main',
          sourceName: '主站',
          lineId: 'default',
          lineName: '默认线路',
          episodes: [],
          episodes_titles: []
        }
      ]
    };
  },

  async resolvePlayUrl(ctx, { playUrl, sourceId, lineId, episodeIndex }) {
    ctx.log.info('resolvePlayUrl', sourceId, lineId, episodeIndex, playUrl);
    return {
      url: playUrl,
      type: 'auto',
      headers: {}
    };
  }
};`;

function getNowVersion() {
  return new Date().toISOString();
}

function buildEmptyRegistry(): SourceScriptRegistry {
  return { items: [] };
}

async function loadRegistry(): Promise<SourceScriptRegistry> {
  const raw = await db.getGlobalValue(SOURCE_SCRIPT_REGISTRY_KEY);
  if (!raw) {
    return buildEmptyRegistry();
  }

  try {
    const parsed = JSON.parse(raw) as SourceScriptRegistry;
    if (!parsed || !Array.isArray(parsed.items)) {
      return buildEmptyRegistry();
    }
    return parsed;
  } catch {
    return buildEmptyRegistry();
  }
}

async function saveRegistry(registry: SourceScriptRegistry) {
  await db.setGlobalValue(
    SOURCE_SCRIPT_REGISTRY_KEY,
    JSON.stringify(registry)
  );
}

function assertScriptKey(key: string) {
  if (!/^[a-zA-Z0-9_-]+$/.test(key)) {
    throw new Error('脚本 Key 仅支持字母、数字、下划线和中划线');
  }
}

function assertSafeCode(code: string) {
  const blockedPatterns = [
    /\brequire\s*\(/,
    /\bprocess\./,
    /\bchild_process\b/,
    /\bfs\b/,
    /\bimport\s*\(/,
    /\beval\s*\(/,
    /\bnew\s+Function\b/,
  ];

  for (const pattern of blockedPatterns) {
    if (pattern.test(code)) {
      throw new Error(`脚本包含不允许的用法: ${pattern}`);
    }
  }
}

function createLogCollector() {
  const logs: string[] = [];

  const push = (level: string, args: any[]) => {
    const rendered = args
      .map((arg) => {
        if (typeof arg === 'string') return arg;
        try {
          return JSON.stringify(arg);
        } catch {
          return String(arg);
        }
      })
      .join(' ');

    logs.push(`[${level}] ${rendered}`);
    if (logs.length > 50) {
      logs.shift();
    }
  };

  return {
    logs,
    log: {
      info: (...args: any[]) => push('info', args),
      warn: (...args: any[]) => push('warn', args),
      error: (...args: any[]) => push('error', args),
    },
  };
}

function withTimeout<T>(promise: Promise<T>, timeoutMs = DEFAULT_TIMEOUT_MS) {
  return Promise.race([
    promise,
    new Promise<T>((_, reject) => {
      setTimeout(() => reject(new Error(`执行超时(${timeoutMs}ms)`)), timeoutMs);
    }),
  ]);
}

function createCacheHelpers(scriptId: string) {
  const prefix = `source-script-cache:${scriptId}:`;

  return {
    async get(key: string) {
      const raw = await db.getGlobalValue(`${prefix}${key}`);
      if (!raw) {
        return null;
      }

      try {
        const parsed = JSON.parse(raw) as { value: string; expiresAt: number };
        if (parsed.expiresAt && parsed.expiresAt < Date.now()) {
          await db.deleteGlobalValue(`${prefix}${key}`);
          return null;
        }
        return parsed.value ?? null;
      } catch {
        return raw;
      }
    },
    async set(key: string, value: string, ttlSec = 300) {
      await db.setGlobalValue(
        `${prefix}${key}`,
        JSON.stringify({
          value,
          expiresAt: Date.now() + ttlSec * 1000,
        })
      );
    },
    async del(key: string) {
      await db.deleteGlobalValue(`${prefix}${key}`);
    },
  };
}

function createUtils() {
  return {
    buildUrl(base: string, query?: Record<string, string | number | boolean>) {
      const url = new URL(base);
      Object.entries(query || {}).forEach(([key, value]) => {
        url.searchParams.set(key, String(value));
      });
      return url.toString();
    },
    joinUrl(base: string, path: string) {
      return new URL(path, base).toString();
    },
    randomUA() {
      return 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36';
    },
    sleep(ms: number) {
      return new Promise((resolve) => setTimeout(resolve, ms));
    },
    base64Encode(value: string) {
      return Buffer.from(value, 'utf8').toString('base64');
    },
    base64Decode(value: string) {
      return Buffer.from(value, 'base64').toString('utf8');
    },
    now() {
      return Date.now();
    },
  };
}

function createScriptFactory(code: string) {
  assertSafeCode(code);

  return new Function(
    `"use strict";
const process = undefined;
const require = undefined;
const module = undefined;
const exports = undefined;
const fetch = undefined;
${code}`
  ) as () => any;
}

async function createScriptContext(script: SourceScriptRecord, configValues?: Record<string, string>) {
  const { logs, log } = createLogCollector();
  const cache = createCacheHelpers(script.id);

  const fetcher = async (input: {
    url: string;
    method?: string;
    headers?: Record<string, string>;
    query?: Record<string, string | number | boolean>;
    body?: string;
    json?: unknown;
    timeoutMs?: number;
  }) => {
    const url = new URL(input.url);
    Object.entries(input.query || {}).forEach(([key, value]) => {
      url.searchParams.set(key, String(value));
    });

    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
      throw new Error(`不支持的协议: ${url.protocol}`);
    }

    const controller = new AbortController();
    const timeoutId = setTimeout(
      () => controller.abort(),
      input.timeoutMs || DEFAULT_TIMEOUT_MS
    );

    try {
      const response = await fetch(url.toString(), {
        method: input.method || 'GET',
        headers: {
          ...(input.json ? { 'Content-Type': 'application/json' } : {}),
          ...(input.headers || {}),
        },
        body: input.json !== undefined ? JSON.stringify(input.json) : input.body,
        signal: controller.signal,
      });

      return {
        status: response.status,
        ok: response.ok,
        url: response.url,
        headers: Object.fromEntries(response.headers.entries()),
        text: () => response.text(),
        json: <T = any>() => response.json() as Promise<T>,
        arrayBuffer: () => response.arrayBuffer(),
      };
    } finally {
      clearTimeout(timeoutId);
    }
  };

  return {
    ctx: Object.freeze({
      fetch: fetcher,
      request: {
        get: (url: string, options?: Omit<Parameters<typeof fetcher>[0], 'url' | 'method'>) =>
          fetcher({ url, method: 'GET', ...(options || {}) }),
        post: (url: string, options?: Omit<Parameters<typeof fetcher>[0], 'url' | 'method'>) =>
          fetcher({ url, method: 'POST', ...(options || {}) }),
        async getHtml(url: string, options?: Omit<Parameters<typeof fetcher>[0], 'url' | 'method'>) {
          const response = await fetcher({ url, method: 'GET', ...(options || {}) });
          const text = await response.text();
          return cheerio.load(text);
        },
        async getJson<T = any>(url: string, options?: Omit<Parameters<typeof fetcher>[0], 'url' | 'method'>) {
          const response = await fetcher({ url, method: 'GET', ...(options || {}) });
          return response.json<T>();
        },
      },
      html: {
        load: (html: string) => cheerio.load(html),
      },
      json: {
        parse<T = any>(text: string, fallback?: T) {
          try {
            return JSON.parse(text) as T;
          } catch {
            return fallback as T;
          }
        },
        stringify(value: unknown) {
          return JSON.stringify(value);
        },
      },
      utils: createUtils(),
      cache,
      log,
      config: {
        get: (key: string) => configValues?.[key],
        require: (key: string) => {
          const value = configValues?.[key];
          if (!value) {
            throw new Error(`缺少脚本配置: ${key}`);
          }
          return value;
        },
        all: () => ({ ...(configValues || {}) }),
      },
      runtime: {
        scriptId: script.id,
        sourceKey: script.key,
        sourceName: script.name,
        version: script.version,
      },
    }),
    logs,
  };
}

function normalizeScript(script: any) {
  if (!script || typeof script !== 'object') {
    throw new Error('脚本必须返回对象');
  }
  return script;
}

async function getEnabledSourceScriptByKey(key: string) {
  const registry = await loadRegistry();
  const item = registry.items.find((record) => record.key === key);
  if (!item) {
    throw new Error('脚本不存在');
  }
  if (!item.enabled) {
    throw new Error('脚本已停用');
  }
  return item;
}

async function compileSourceScript(
  script: SourceScriptRecord,
  configValues?: Record<string, string>
) {
  const factory = createScriptFactory(script.code);
  const compiled = normalizeScript(factory());
  const context = await createScriptContext(script, configValues);
  return {
    compiled,
    ...context,
  };
}

export async function executeSavedSourceScript(input: {
  key: string;
  hook: SourceScriptHook;
  payload?: Record<string, any>;
  configValues?: Record<string, string>;
}): Promise<SourceScriptTestResult> {
  const startedAt = Date.now();
  const script = await getEnabledSourceScriptByKey(input.key);
  const { compiled, ctx, logs } = await compileSourceScript(
    script,
    input.configValues
  );

  const hook = compiled[input.hook];
  if (typeof hook !== 'function') {
    throw new Error(`脚本未实现 ${input.hook} hook`);
  }

  const result = await withTimeout(
    Promise.resolve(hook(ctx, input.payload || {})),
    DEFAULT_TIMEOUT_MS
  );

  return {
    ok: true,
    durationMs: Date.now() - startedAt,
    logs,
    meta: compiled.meta,
    result,
  };
}

export async function listEnabledSourceScripts(): Promise<PublicSourceScriptSummary[]> {
  const registry = await loadRegistry();
  return registry.items
    .filter((item) => item.enabled)
    .sort((a, b) => b.updatedAt - a.updatedAt)
    .map((item) => ({
      id: item.id,
      key: item.key,
      name: item.name,
      description: item.description,
      version: item.version,
      updatedAt: item.updatedAt,
    }));
}

export async function listSourceScripts() {
  const registry = await loadRegistry();
  return registry.items.sort((a, b) => b.updatedAt - a.updatedAt);
}

export async function getSourceScript(id: string) {
  const registry = await loadRegistry();
  return registry.items.find((item) => item.id === id) || null;
}

export async function saveSourceScript(input: {
  id?: string;
  key: string;
  name: string;
  description?: string;
  code: string;
  enabled?: boolean;
}) {
  assertScriptKey(input.key);
  assertSafeCode(input.code);

  const registry = await loadRegistry();
  const now = Date.now();
  const existing = input.id
    ? registry.items.find((item) => item.id === input.id)
    : undefined;

  if (!existing && registry.items.some((item) => item.key === input.key)) {
    throw new Error('脚本 Key 已存在');
  }

  if (existing) {
    existing.history.unshift({
      version: existing.version,
      code: existing.code,
      updatedAt: existing.updatedAt,
    });
    existing.history = existing.history.slice(0, MAX_HISTORY_ITEMS);
    existing.key = input.key;
    existing.name = input.name;
    existing.description = input.description || '';
    existing.code = input.code;
    existing.enabled = input.enabled ?? existing.enabled;
    existing.updatedAt = now;
    existing.version = getNowVersion();
    await saveRegistry(registry);
    return existing;
  }

  const created: SourceScriptRecord = {
    id: nanoid(),
    key: input.key,
    name: input.name,
    description: input.description || '',
    code: input.code,
    enabled: input.enabled ?? true,
    version: getNowVersion(),
    createdAt: now,
    updatedAt: now,
    history: [],
  };

  registry.items.unshift(created);
  await saveRegistry(registry);
  return created;
}

export async function importSourceScripts(items: SourceScriptImportItem[]) {
  const registry = await loadRegistry();
  const now = Date.now();
  const imported: SourceScriptRecord[] = [];

  for (const item of items) {
    if (!item?.key || !item?.name || !item?.code) {
      throw new Error('导入脚本缺少必要字段: key/name/code');
    }

    assertScriptKey(item.key);
    assertSafeCode(item.code);

    const existing = registry.items.find((record) => record.key === item.key);

    if (existing) {
      existing.history.unshift({
        version: existing.version,
        code: existing.code,
        updatedAt: existing.updatedAt,
      });
      existing.history = existing.history.slice(0, MAX_HISTORY_ITEMS);
      existing.name = item.name;
      existing.description = item.description || '';
      existing.code = item.code;
      existing.enabled = item.enabled ?? existing.enabled;
      existing.updatedAt = now;
      existing.version = getNowVersion();
      imported.push(existing);
      continue;
    }

    const created: SourceScriptRecord = {
      id: nanoid(),
      key: item.key,
      name: item.name,
      description: item.description || '',
      code: item.code,
      enabled: item.enabled ?? true,
      version: getNowVersion(),
      createdAt: now,
      updatedAt: now,
      history: [],
    };
    registry.items.unshift(created);
    imported.push(created);
  }

  await saveRegistry(registry);
  return imported;
}

export async function deleteSourceScript(id: string) {
  const registry = await loadRegistry();
  const nextItems = registry.items.filter((item) => item.id !== id);
  if (nextItems.length === registry.items.length) {
    throw new Error('脚本不存在');
  }
  registry.items = nextItems;
  await saveRegistry(registry);
}

export async function toggleSourceScriptEnabled(id: string) {
  const registry = await loadRegistry();
  const target = registry.items.find((item) => item.id === id);
  if (!target) {
    throw new Error('脚本不存在');
  }
  target.enabled = !target.enabled;
  target.updatedAt = Date.now();
  await saveRegistry(registry);
  return target;
}

export async function restoreSourceScriptHistory(id: string, version: string) {
  const registry = await loadRegistry();
  const target = registry.items.find((item) => item.id === id);
  if (!target) {
    throw new Error('脚本不存在');
  }

  const history = target.history.find((item) => item.version === version);
  if (!history) {
    throw new Error('历史版本不存在');
  }

  target.history.unshift({
    version: target.version,
    code: target.code,
    updatedAt: target.updatedAt,
  });
  target.history = target.history.slice(0, MAX_HISTORY_ITEMS);
  target.code = history.code;
  target.version = getNowVersion();
  target.updatedAt = Date.now();
  await saveRegistry(registry);
  return target;
}

export async function testSourceScript(input: {
  code: string;
  hook: SourceScriptHook;
  payload: Record<string, any>;
  name?: string;
  key?: string;
  configValues?: Record<string, string>;
}): Promise<SourceScriptTestResult> {
  const startedAt = Date.now();
  try {
    const tempScript: SourceScriptRecord = {
      id: 'test-script',
      key: input.key || 'test-script',
      name: input.name || '测试脚本',
      description: '',
      enabled: true,
      version: 'test',
      code: input.code,
      createdAt: startedAt,
      updatedAt: startedAt,
      history: [],
    };

    const factory = createScriptFactory(input.code);
    const compiled = normalizeScript(factory());
    const hook = compiled[input.hook];
    if (typeof hook !== 'function') {
      throw new Error(`脚本未实现 ${input.hook} hook`);
    }

    const { ctx, logs } = await createScriptContext(tempScript, input.configValues);
    const result = await withTimeout(
      Promise.resolve(hook(ctx, input.payload)),
      DEFAULT_TIMEOUT_MS
    );

    return {
      ok: true,
      durationMs: Date.now() - startedAt,
      logs,
      meta: compiled.meta,
      result,
    };
  } catch (error) {
    return {
      ok: false,
      durationMs: Date.now() - startedAt,
      logs: [],
      error: (error as Error).message,
    };
  }
}

export function getDefaultSourceScriptTemplate() {
  return DEFAULT_SCRIPT_TEMPLATE;
}

export function buildScriptSourceValue(scriptKey: string, sourceId?: string) {
  return `${SCRIPT_SOURCE_PREFIX}${scriptKey}:${sourceId || 'default'}`;
}

export function parseScriptSourceValue(source: string) {
  if (!source.startsWith(SCRIPT_SOURCE_PREFIX)) {
    return null;
  }

  const rest = source.slice(SCRIPT_SOURCE_PREFIX.length);
  const separatorIndex = rest.indexOf(':');
  if (separatorIndex === -1) {
    return {
      scriptKey: rest,
      sourceId: 'default',
    };
  }

  return {
    scriptKey: rest.slice(0, separatorIndex),
    sourceId: rest.slice(separatorIndex + 1) || 'default',
  };
}

export function encodeScriptEpisodePayload(payload: Record<string, any>) {
  return `${SCRIPT_EPISODE_PREFIX}${Buffer.from(
    JSON.stringify(payload),
    'utf8'
  ).toString('base64')}`;
}

export function decodeScriptEpisodePayload(value: string) {
  if (!value.startsWith(SCRIPT_EPISODE_PREFIX)) {
    return null;
  }

  try {
    return JSON.parse(
      Buffer.from(
        value.slice(SCRIPT_EPISODE_PREFIX.length),
        'base64'
      ).toString('utf8')
    ) as Record<string, any>;
  } catch {
    return null;
  }
}

export function normalizeScriptSources(result: any): ScriptSourceDescriptor[] {
  if (!Array.isArray(result)) {
    return [{ id: 'default', name: '默认源' }];
  }

  return result
    .filter((item) => item && item.id)
    .map((item) => ({
      id: String(item.id),
      name: String(item.name || item.id),
    }));
}

export function normalizeScriptSearchResults(input: {
  scriptKey: string;
  scriptName: string;
  sourceId: string;
  sourceName: string;
  result: any;
}) {
  const list = Array.isArray(input.result?.list) ? input.result.list : [];
  return list.map((item: any) => ({
    id: String(item.id),
    title: String(item.title || ''),
    poster: item.poster || '',
    episodes: [],
    episodes_titles: [],
    source: buildScriptSourceValue(input.scriptKey, input.sourceId),
    source_name: `${input.scriptName} / ${input.sourceName}`,
    year: item.year || '',
    desc: item.desc || '',
    type_name: item.type_name || '',
    douban_id: item.douban_id || 0,
    vod_remarks: item.vod_remarks,
  }));
}

export function normalizeScriptDetailResult(input: {
  source: string;
  scriptKey: string;
  scriptName: string;
  sourceId: string;
  sourceName: string;
  detailId: string;
  result: any;
}) {
  const playbacks = Array.isArray(input.result?.playbacks)
    ? input.result.playbacks
    : [
        {
          sourceId: input.sourceId,
          sourceName: input.sourceName,
          lineId: 'default',
          lineName: '默认线路',
          episodes: input.result?.episodes || [],
          episodes_titles: input.result?.episodes_titles || [],
        },
      ];

  const flattenedEpisodes: string[] = [];
  const flattenedTitles: string[] = [];

  playbacks.forEach((playback: any) => {
    const playbackSourceId = String(playback.sourceId || input.sourceId);
    const playbackSourceName = String(playback.sourceName || input.sourceName);
    const lineId = String(playback.lineId || 'default');
    const lineName = String(playback.lineName || '默认线路');
    const titles = Array.isArray(playback.episodes_titles)
      ? playback.episodes_titles
      : [];
    const episodes = Array.isArray(playback.episodes) ? playback.episodes : [];

    episodes.forEach((episode: any, index: number) => {
      const playUrl =
        typeof episode === 'string'
          ? episode
          : String(episode?.playUrl || episode?.url || '');
      const episodeTitle =
        typeof episode === 'object' && episode?.title
          ? String(episode.title)
          : String(titles[index] || `第${index + 1}集`);

      flattenedEpisodes.push(
        encodeScriptEpisodePayload({
          script: input.scriptKey,
          sourceId: playbackSourceId,
          sourceName: playbackSourceName,
          lineId,
          lineName,
          playUrl,
          episodeIndex: index,
        })
      );
      flattenedTitles.push(`${playbackSourceName} / ${lineName} / ${episodeTitle}`);
    });
  });

  return {
    id: input.detailId,
    title: String(input.result?.title || ''),
    poster: input.result?.poster || '',
    episodes: flattenedEpisodes,
    episodes_titles: flattenedTitles,
    source: input.source,
    source_name: `${input.scriptName} / ${input.sourceName}`,
    class: input.result?.class,
    year: input.result?.year || '',
    desc: input.result?.desc || '',
    type_name: input.result?.type_name || '',
    douban_id: input.result?.douban_id || 0,
    vod_remarks: input.result?.vod_remarks,
    vod_total: input.result?.vod_total,
    proxyMode: false,
  };
}

export async function resolveScriptDetailPlaybacks(input: {
  scriptKey: string;
  sourceId: string;
  result: any;
}) {
  const playbacks = Array.isArray(input.result?.playbacks)
    ? input.result.playbacks
    : [
        {
          sourceId: input.sourceId,
          sourceName: input.sourceId,
          lineId: 'default',
          lineName: '默认线路',
          episodes: input.result?.episodes || [],
          episodes_titles: input.result?.episodes_titles || [],
        },
      ];

  const resolvedPlaybacks = await Promise.all(
    playbacks.map(async (playback: any) => {
      const playbackSourceId = String(playback.sourceId || input.sourceId);
      const lineId = String(playback.lineId || 'default');
      const episodes = Array.isArray(playback.episodes) ? playback.episodes : [];

      const resolvedEpisodes = await Promise.all(
        episodes.map(async (episode: any, index: number) => {
          const playUrl =
            typeof episode === 'string'
              ? episode
              : String(episode?.playUrl || episode?.url || '');

          try {
            const execution = await executeSavedSourceScript({
              key: input.scriptKey,
              hook: 'resolvePlayUrl',
              payload: {
                playUrl,
                sourceId: playbackSourceId,
                lineId,
                episodeIndex: index,
              },
            });

            return execution.result?.url || playUrl;
          } catch (error) {
            const message = error instanceof Error ? error.message : '';
            if (message.includes('未实现 resolvePlayUrl hook')) {
              return playUrl;
            }
            return playUrl;
          }
        })
      );

      return {
        ...playback,
        episodes: resolvedEpisodes,
      };
    })
  );

  return {
    ...input.result,
    playbacks: resolvedPlaybacks,
  };
}