import { createPublicKey, verify } from 'node:crypto';
import { eq } from 'drizzle-orm';
import { Hono } from 'hono';
import { bodyLimit } from 'hono/body-limit';
import { ZodError } from 'zod';
import { publicUser, type AppDatabase } from '../auth';
import { users, discordReceipts } from '../db/schema';
import { ApiError, HabitService } from '../habits/service';
import { ControlStore } from './state';
import { interactionSchema, type Context, type Reply } from './types';
import { dailyAction, today } from './daily';
import { manageHabits, manageTasks, managementAction } from './management';
import { history, historyAction } from './history';
import { preferences, preferencesAction } from './preferences';
import { progress, progressAction, type DeferredMessage, type ProgressOperations } from './progress';
import { message } from './ui';
import { help } from './help';
import { commandGraphicAction } from './command-graphics';

export type CommandConfig = { publicKey: string; applicationId: string; origin: string; remindersAvailable?: boolean };
export type DeferredDispatch = {
  progress?: ProgressOperations;
  complete?: (interaction: import('./types').Interaction, result: DeferredMessage) => Promise<void>;
  schedule?: (job: () => Promise<void>) => void;
};
/** Edit the deferred original exactly once. Never retry an uncertain network result. */
export async function completeDeferred(i: import('./types').Interaction, result: DeferredMessage) {
  const body = new FormData();
  const payload = { ...result.message, flags: undefined, allowed_mentions: { parse: [] }, attachments: result.image ? [{ id: 0, filename: 'mina-progress.png', description: (result.imageDescription ?? result.message.content)?.slice(0, 1024) }] : [] };
  body.set('payload_json', JSON.stringify(payload));
  if (result.image) body.set('files[0]', new Blob([new Uint8Array(result.image)], { type: 'image/png' }), 'mina-progress.png');
  const response = await fetch(`https://discord.com/api/v10/webhooks/${i.application_id}/${encodeURIComponent(i.token!)}/messages/@original`, { method: 'PATCH', body, redirect: 'error', signal: AbortSignal.timeout(15000) });
  if (!response.ok) throw new Error('Deferred Discord response was rejected.');
}
export function createDiscordRoutes(db: AppDatabase, config: CommandConfig, now = Date.now, changed: (userId: string) => void = () => {}, dispatch: DeferredDispatch = {}) {
  const app = new Hono();
  const key = /^[a-f\d]{64}$/i.test(config.publicKey) ? createPublicKey({ key: Buffer.concat([Buffer.from('302a300506032b6570032100', 'hex'), Buffer.from(config.publicKey, 'hex')]), format: 'der', type: 'spki' }) : null;
  app.use('*', bodyLimit({ maxSize: 64 * 1024 }));
  app.post('/', async c => {
    c.header('Cache-Control', 'no-store');
    if (!key) return c.json({ error: 'Discord commands are not configured.' }, 503);
    const signature = c.req.header('X-Signature-Ed25519') ?? '', timestamp = c.req.header('X-Signature-Timestamp') ?? '';
    const body = await c.req.text();
    if (!/^\d{10,12}$/.test(timestamp) || Math.abs(now() - Number(timestamp) * 1000) > 300000 || !/^[a-f\d]{128}$/i.test(signature) || !verify(null, Buffer.from(timestamp + body), key, Buffer.from(signature, 'hex')))
      return c.json({ error: 'Invalid request signature.' }, 401);
    let value: unknown;
    try { value = JSON.parse(body); } catch { return c.json({ error: "Malformed JSON." }, 400); }
    const parsed = interactionSchema.safeParse(value);
    if (!parsed.success || parsed.data.application_id !== config.applicationId) return c.json({ error: 'Invalid interaction.' }, 400);
    const i = parsed.data;
    if (i.type === 1) return c.json({ type: 1 });
    const profile = i.guild_id ? i.member?.user : i.user;
    if (!profile || ![2, 3, 4, 5].includes(i.type)) return c.json({ error: 'Unsupported interaction.' }, 400);
    // Help needs no account creation, habit synchronization, or saved UI state.
    if (i.type === 2 && i.data?.name === 'help') return c.json(help(!!i.guild_id, config.origin));
    let pending: (() => Promise<DeferredMessage>) | undefined;
    // Resolve the account before queueing catch-up; no transaction is held across yields.
    const existing = db.select().from(users).where(eq(users.discordId, profile.id)).get();
    const userId = existing?.id ?? crypto.randomUUID();
    if (!existing) db.insert(users).values({ id: userId, discordId: profile.id, username: profile.username, globalName: profile.global_name, avatarHash: profile.avatar, createdAt: now(), updatedAt: now() }).run();
    const receipt = db.select().from(discordReceipts).where(eq(discordReceipts.id, i.id)).get();
    if (receipt && receipt.expiresAt > now()) return c.json(receipt.response);
    const owner = publicUser(db.select().from(users).where(eq(users.id, userId)).get()!);
    const reply = await HabitService.withPrepared(db, owner, now, service => db.transaction((): Reply => {
      const receipt = db.select().from(discordReceipts).where(eq(discordReceipts.id, i.id)).get();
      if (receipt && receipt.expiresAt > now()) return receipt.response;
      const controls = new ControlStore(db, userId, now()); controls.prune();
      const ctx: Context = { db, service, controls, interaction: i, now: now(), origin: config.origin, remindersAvailable: config.remindersAvailable ?? false, changed: () => changed(userId), progress: dispatch.progress, defer: i.token ? job => { pending = job; } : undefined };
      let result: Reply;
      try {
        if (i.type === 4) result = { type: 8, data: { choices: [] } };
        else if (i.type === 2 && i.data?.name === 'tasks') result = manageTasks(ctx);
        else if (i.type === 2 && i.data?.name === 'habits') result = manageHabits(ctx);
        else if (i.type === 2 && i.data?.name === 'progress') result = progress(ctx);
        else if (i.type === 2 && i.data?.name === 'today') result = today(ctx);
        else if (i.type === 2 && ['settings', 'reminders'].includes(i.data?.name ?? '')) result = preferences(ctx, i.data!.name!);
        else if (i.type === 2 && i.data?.name === 'history') result = history(ctx);
        else if ([3, 5].includes(i.type)) {
          const state = controls.read(i.data?.custom_id ?? '');
          result = commandGraphicAction(ctx, state.action, state.payload) ?? progressAction(ctx, state.action, state.payload) ?? preferencesAction(ctx, state.action, state.payload) ?? historyAction(ctx, state.action, state.payload) ?? dailyAction(ctx, state.action, state.payload) ?? managementAction(ctx, state.action, state.payload) ?? message(ctx, 'Run /help to see available commands.', [], false);
        } else result = message(ctx, 'Run /help to see available commands.', [], false);
      } catch (error) {
        if (!(error instanceof ApiError) && !(error instanceof ZodError)) throw error;
        result = message(ctx, error instanceof ApiError ? error.message : 'Check the entered values and try again.', [], false);
      }
      db.insert(discordReceipts).values({ id: i.id, userId, response: result, expiresAt: now() + 86400000 }).run();
      return result;
    }));
    if (pending) {
      const work = pending;
      const job = async () => {
        let result: DeferredMessage;
        try { result = await work(); }
        catch (error) { result = { message: { content: error instanceof ApiError ? error.message : 'Could not complete this action. Check the destination before trying another share.', components: [], allowed_mentions: { parse: [] } } }; }
        try { await (dispatch.complete ?? completeDeferred)(i, result); }
        catch { console.error('Discord deferred reply failed; it will not be retried.'); }
      };
      (dispatch.schedule ?? (job => { setTimeout(() => { void job(); }, 0); }))(job);
    }
    return c.json(reply);
  });
  return app;
}