import path from "node:path";
import { randomUUID } from "node:crypto";
import { config } from "../config";
import { logger } from "../logger";
import { TtsCacheStore } from "./cache";
import type { TtsNormalizedRequest, TtsProviderAdapter, TtsSynthesizeInput } from "./provider";
import { TtsServiceError, normalizeTtsRequest } from "./provider";
import { TencentTtsProvider } from "./providers/tencent";
import { VolcengineTtsProvider } from "./providers/volcengine";
import { createTtsAudioTicket, verifyTtsAudioTicket } from "./ticket";

const TTS_AUDIO_TICKET_TTL_MS = 10 * 60 * 1000;
const TTS_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
const TTS_CACHE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
const TTS_PROVIDER_CONCURRENCY = 4;
const TTS_PROVIDER_QUEUE_TIMEOUT_MS = 10 * 60 * 1000;
const TTS_BACKGROUND_FAILURE_TTL_MS = 5 * 60 * 1000;
const TTS_SYNTHESIZE_INLINE_WAIT_MS = 800;

interface TtsAudioAccess {
  uid: string;
  cacheKey: string;
  exp: number;
}

interface TtsBackgroundFailure {
  code: string;
  message: string;
  status: number;
  expiresAt: number;
}

type TtsSynthesisStatus =
  | { state: "ready" }
  | { state: "pending" }
  | { state: "missing" }
  | { state: "error"; code: string; message: string; status: number };

interface TtsServiceOptions {
  provider?: TtsProviderAdapter;
  cache?: TtsCacheStore;
  inlineWaitMs?: number;
}

function sleep(ms: number): Promise<void> {
  const waitMs = Math.max(0, Math.round(Number(ms) || 0));
  return new Promise((resolve) => {
    setTimeout(resolve, waitMs);
  });
}

/**
 * 最小并发闸门：
 * 1. 每实例只允许少量上游 TTS 并发；
 * 2. 等待结束后立即唤醒下一个请求；
 * 3. v1 不做复杂优先级，保持实现确定性。
 */
class AsyncSemaphore {
  private capacity: number;
  private active: number;
  private queue: Array<() => void>;

  constructor(capacity: number) {
    this.capacity = Math.max(1, capacity);
    this.active = 0;
    this.queue = [];
  }

  async use<T>(task: () => Promise<T>, waitTimeoutMs: number): Promise<T> {
    await this.acquire(waitTimeoutMs);
    try {
      return await task();
    } finally {
      this.release();
    }
  }

  private acquire(waitTimeoutMs: number): Promise<void> {
    if (this.active < this.capacity) {
      this.active += 1;
      return Promise.resolve();
    }
    return new Promise((resolve, reject) => {
      const timeoutMs = Math.max(0, Math.round(Number(waitTimeoutMs) || 0));
      let timeout: NodeJS.Timeout | null = null;
      const resume = () => {
        if (timeout) {
          clearTimeout(timeout);
          timeout = null;
        }
        this.active += 1;
        resolve();
      };
      this.queue.push(resume);
      if (timeoutMs <= 0) {
        return;
      }
      timeout = setTimeout(() => {
        const index = this.queue.indexOf(resume);
        if (index >= 0) {
          this.queue.splice(index, 1);
        }
        reject(new TtsServiceError("TTS_BUSY", "语音生成繁忙，请稍后重试", 503));
      }, timeoutMs);
    });
  }

  private release(): void {
    this.active = Math.max(0, this.active - 1);
    const next = this.queue.shift();
    if (next) next();
  }
}

function createProvider(): TtsProviderAdapter {
  const providerName = String(config.tts.provider || "tencent")
    .trim()
    .toLowerCase();
  if (providerName === "volcengine") {
    return new VolcengineTtsProvider();
  }
  if (providerName === "tencent") {
    return new TencentTtsProvider();
  }
  throw new TtsServiceError("TTS_DISABLED", `不支持的 TTS provider: ${providerName}`, 503);
}

export class TtsService {
  private provider: TtsProviderAdapter;
  private cache: TtsCacheStore;
  private semaphore: AsyncSemaphore;
  private inflight: Map<string, Promise<void>>;
  private failures: Map<string, TtsBackgroundFailure>;
  private inlineWaitMs: number;

  constructor(options?: TtsServiceOptions) {
    this.provider = options?.provider ?? createProvider();
    this.cache =
      options?.cache ??
      new TtsCacheStore({
        cacheDir: path.resolve(process.cwd(), "data/tts-cache"),
        ttlMs: TTS_CACHE_TTL_MS,
        maxTotalBytes: TTS_CACHE_TOTAL_MAX_BYTES,
        // 不同 TTS 供应商的分片/码率差异较大，单文件上限统一改由配置驱动。
        maxFileBytes: config.tts.cacheFileMaxBytes
      });
    this.semaphore = new AsyncSemaphore(TTS_PROVIDER_CONCURRENCY);
    this.inflight = new Map();
    this.failures = new Map();
    this.inlineWaitMs = Math.max(0, Math.round(Number(options?.inlineWaitMs) || TTS_SYNTHESIZE_INLINE_WAIT_MS));
  }

  private ticketSecret(): string {
    const secret = `${config.sync.secretCurrent}:${config.gatewayToken}`;
    if (!config.sync.secretCurrent) {
      throw new TtsServiceError("TTS_DISABLED", "同步密钥未配置，无法签发音频票据", 503);
    }
    return secret;
  }

  private ensureEnabled(): void {
    if (!config.tts.enabled) {
      throw new TtsServiceError("TTS_DISABLED", "TTS 服务未配置", 503);
    }
  }

  private buildAudioAccessUrls(baseUrl: string, uid: string, cacheKey: string) {
    const exp = Date.now() + TTS_AUDIO_TICKET_TTL_MS;
    const ticket = createTtsAudioTicket(this.ticketSecret(), { uid, cacheKey, exp });
    return {
      audioUrl: `${baseUrl}/api/miniprogram/tts/audio/${cacheKey}?ticket=${encodeURIComponent(ticket)}`,
      statusUrl: `${baseUrl}/api/miniprogram/tts/status/${cacheKey}?ticket=${encodeURIComponent(ticket)}`,
      expiresAt: new Date(exp).toISOString()
    };
  }

  private getRecentFailure(cacheKey: string): TtsBackgroundFailure | null {
    const row = this.failures.get(cacheKey);
    if (!row) {
      return null;
    }
    if (row.expiresAt <= Date.now()) {
      this.failures.delete(cacheKey);
      return null;
    }
    return row;
  }

  private rememberFailure(cacheKey: string, error: unknown): void {
    const failure =
      error instanceof TtsServiceError
        ? {
            code: error.code,
            message: error.message,
            status: error.status,
            expiresAt: Date.now() + TTS_BACKGROUND_FAILURE_TTL_MS
          }
        : {
            code: "TTS_INTERNAL_ERROR",
            message: error instanceof Error && error.message ? error.message : "语音生成失败",
            status: 500,
            expiresAt: Date.now() + TTS_BACKGROUND_FAILURE_TTL_MS
          };
    this.failures.set(cacheKey, failure);
  }

  private async synthesizeCacheMiss(normalized: TtsNormalizedRequest): Promise<void> {
    const result = await this.semaphore.use(async () => {
      return await this.provider.synthesize({
        text: normalized.normalizedText,
        voice: normalized.voice,
        speed: normalized.speed,
        traceId: randomUUID()
      });
    }, TTS_PROVIDER_QUEUE_TIMEOUT_MS);
    await this.cache.put(normalized.cacheKey, result.audio, result.contentType);
  }

  private ensureBackgroundSynthesis(normalized: TtsNormalizedRequest): void {
    if (this.inflight.has(normalized.cacheKey)) {
      return;
    }
    this.failures.delete(normalized.cacheKey);
    const job = (async () => {
      try {
        await this.synthesizeCacheMiss(normalized);
      } catch (error) {
        this.rememberFailure(normalized.cacheKey, error);
        logger.warn(
          {
            scene: normalized.scene,
            textHash: normalized.textHash,
            textLength: normalized.normalizedText.length,
            cacheKey: normalized.cacheKey,
            provider: this.provider.providerName,
            err: error
          },
          "小程序 TTS 后台合成失败"
        );
      } finally {
        this.inflight.delete(normalized.cacheKey);
      }
    })();
    job.catch(() => {
      // 后台任务的错误已经在内部收口到日志与 failure map，这里只防止未处理拒绝。
    });
    this.inflight.set(normalized.cacheKey, job);
  }

  /**
   * 首次 miss 时短暂等待后台任务：
   * 1. 短文本常在 1 秒内就能合成完成，直接返回 ready 可省掉一轮轮询；
   * 2. 等待窗口很短，慢请求仍按原有 pending 模式异步完成；
   * 3. 这里复用同一个 inflight 任务，不会增加上游并发。
   */
  private async waitInlineForReady(cacheKey: string): Promise<void> {
    if (this.inlineWaitMs <= 0) {
      return;
    }
    const inflight = this.inflight.get(cacheKey);
    if (!inflight) {
      return;
    }
    await Promise.race([
      inflight.catch(() => {
        // 失败状态仍交给后续 status 查询和 failure map 处理。
      }),
      sleep(this.inlineWaitMs)
    ]);
  }

  async synthesizeForUser(baseUrl: string, uid: string, input: TtsSynthesizeInput) {
    this.ensureEnabled();
    const normalized = normalizeTtsRequest(input);
    let cached = await this.cache.get(normalized.cacheKey);
    if (!cached) {
      this.ensureBackgroundSynthesis(normalized);
      await this.waitInlineForReady(normalized.cacheKey);
      cached = await this.cache.get(normalized.cacheKey);
    }
    const ticketResult = this.buildAudioAccessUrls(baseUrl, uid, normalized.cacheKey);
    const status = cached ? "ready" : "pending";
    logger.info(
      {
        uid,
        scene: normalized.scene,
        textHash: normalized.textHash,
        textLength: normalized.normalizedText.length,
        cacheKey: normalized.cacheKey,
        provider: this.provider.providerName,
        cacheHit: !!cached,
        synthStatus: status
      },
      cached ? "小程序 TTS 合成完成" : "小程序 TTS 合成任务已提交"
    );
    return {
      ok: true,
      cacheKey: normalized.cacheKey,
      cached: !!cached,
      status,
      audioUrl: ticketResult.audioUrl,
      statusUrl: ticketResult.statusUrl,
      expiresAt: ticketResult.expiresAt
    };
  }

  async getSynthesisStatus(cacheKey: string): Promise<TtsSynthesisStatus> {
    // 先看内存态，再碰磁盘，避免轮询刚好撞在 cache.put 的写入窗口里把半成品误删。
    if (this.inflight.has(cacheKey)) {
      return { state: "pending" };
    }
    const cached = await this.cache.get(cacheKey);
    if (cached) {
      return { state: "ready" };
    }
    const failure = this.getRecentFailure(cacheKey);
    if (failure) {
      return {
        state: "error",
        code: failure.code,
        message: failure.message,
        status: failure.status
      };
    }
    return { state: "missing" };
  }

  verifyAudioAccess(cacheKey: string, ticket: string): TtsAudioAccess {
    const payload = verifyTtsAudioTicket(this.ticketSecret(), ticket);
    if (payload.cacheKey !== cacheKey) {
      throw new TtsServiceError("TTS_TICKET_INVALID", "音频票据无效", 403);
    }
    return payload;
  }

  async resolveCachedAudio(cacheKey: string) {
    return await this.cache.get(cacheKey);
  }
}