import { sql } from 'drizzle-orm';
import type { FastifyPluginAsyncZod } from 'fastify-type-provider-zod';
import { z } from 'zod';
import { normalizeLabel } from '@cancerindex/shared';
import { paginate } from '../lib/envelope.js';
import { pageQuery } from '../lib/pagination.js';
import { resolveDrug } from '../lib/resolve.js';
import { AnyList, AnyRecord, camel, camelRows, num, ok, respond } from '../lib/respond.js';
import { pluck } from '../lib/sources.js';

export const drugRoutes: FastifyPluginAsyncZod = async (app) => {
  app.get('/drugs', { schema: { tags: ['drugs'], summary: 'List drugs (generic/INN names; brands are aliases)', querystring: z.object({ q: z.string().trim().min(1).max(100).optional(), kind: z.string().optional(), ...pageQuery }), response: ok(AnyList, true) } }, async (req) => {
    const q = req.query;
    const conds = [sql`true`];
    if (q.kind) conds.push(sql`d.kind = ${q.kind}`);
    if (q.q) {
      const norm = normalizeLabel(q.q);
      conds.push(sql`EXISTS (SELECT 1 FROM drug_aliases a WHERE a.drug_id = d.id AND (a.normalized = ${norm} OR a.normalized LIKE ${norm + '%'}))`);
    }
    const rows = await app.db.execute<Record<string, unknown> & { total: string }>(sql`
      SELECT d.id, d.slug, d.name, d.kind, d.ncit_code, d.chembl_id, d.civic_therapy_id, d.drugbank_id, d.mechanism, d.development_status,
        (SELECT count(*) FROM civic_evidence_items e WHERE e.status = 'ACCEPTED' AND d.id = ANY(e.therapy_ids)) AS evidence_items,
        (SELECT count(*) FROM drug_approvals a WHERE a.drug_id = d.id AND a.status IN ('approved','accelerated','conditional')) AS approvals,
        count(*) OVER() AS total
      FROM drugs d WHERE ${sql.join(conds, sql` AND `)} ORDER BY d.name LIMIT ${q.limit} OFFSET ${q.offset}`);
    const total = rows.length ? num(rows[0]!.total) : 0;
    const data = rows.map((r) => {
      const { total: _t, ...rest } = r;
      return camel(rest);
    });
    const sourceRows = data.length ? await app.db.execute<{ source_id: string }>(sql`SELECT DISTINCT source_id FROM drug_aliases WHERE source_id IS NOT NULL AND drug_id = ANY(${sql.param(data.map((d) => d.id as string))}::text[])`) : [];
    return respond(app, data, pluck(sourceRows, 'source_id'), paginate(total, q.limit, q.offset));
  });

  app.get('/drugs/:id', { schema: { tags: ['drugs'], summary: 'Drug: aliases, curated evidence grouped by cancer, jurisdiction-aware approvals, trials via interventions', params: z.object({ id: z.string().min(1).describe('CI-DRUG-… id or slug') }), response: ok(AnyRecord) } }, async (req) => {
    const { id } = await resolveDrug(app.db, req.params.id);
    const db = app.db;
    const [drug, aliases, evidence, approvals, trials, targets] = await Promise.all([
      db.execute<Record<string, unknown>>(sql`SELECT * FROM drugs WHERE id = ${id}`),
      db.execute<Record<string, unknown>>(sql`SELECT alias, alias_type, source_id FROM drug_aliases WHERE drug_id = ${id} ORDER BY CASE alias_type WHEN 'generic' THEN 0 WHEN 'brand' THEN 1 ELSE 2 END, alias`),
      db.execute<Record<string, unknown>>(sql`
        SELECT e.cancer_id, c.slug AS cancer_slug, c.canonical_name AS cancer_name, e.disease_name, count(*) AS evidence_items,
          count(*) FILTER (WHERE e.evidence_level = 'A') AS level_a, count(*) FILTER (WHERE e.evidence_level = 'B') AS level_b, count(*) FILTER (WHERE e.evidence_level = 'C') AS level_c, count(*) FILTER (WHERE e.evidence_level IN ('D','E')) AS level_de,
          count(*) FILTER (WHERE e.evidence_direction = 'SUPPORTS') AS supports, count(*) FILTER (WHERE e.evidence_direction = 'DOES_NOT_SUPPORT') AS does_not_support,
          count(*) FILTER (WHERE e.significance = 'SENSITIVITYRESPONSE') AS sensitivity, count(*) FILTER (WHERE e.significance = 'RESISTANCE') AS resistance,
          array_agg(DISTINCT gs) FILTER (WHERE gs IS NOT NULL) AS gene_symbols, array_agg(DISTINCT e.civic_id) AS civic_ids, min(p.source_id) AS source_id
        FROM civic_evidence_items e LEFT JOIN cancers c ON c.id = e.cancer_id LEFT JOIN LATERAL unnest(e.gene_symbols) gs ON true LEFT JOIN provenance p ON p.id = e.provenance_id
        WHERE e.status = 'ACCEPTED' AND ${id} = ANY(e.therapy_ids)
        GROUP BY e.cancer_id, c.slug, c.canonical_name, e.disease_name ORDER BY evidence_items DESC`),
      db.execute<Record<string, unknown>>(sql`
        SELECT a.*, c.slug AS cancer_slug, c.canonical_name AS cancer_name, p.source_url, p.retrieved_at, p.dataset_version
        FROM drug_approvals a LEFT JOIN cancers c ON c.id = a.cancer_id LEFT JOIN provenance p ON p.id = a.provenance_id
        WHERE a.drug_id = ${id} ORDER BY a.approval_date DESC NULLS LAST`),
      db.execute<Record<string, unknown>>(sql`
        SELECT t.id, t.nct_id, t.brief_title, t.phases, t.overall_status, t.study_type, t.start_date, t.enrollment_count, t.lead_sponsor, ti.name AS intervention_name, ti.match_type
        FROM trial_interventions ti JOIN clinical_trials t ON t.id = ti.trial_id WHERE ti.drug_id = ${id}
        ORDER BY t.last_update_posted_date DESC NULLS LAST LIMIT 200`),
      db.execute<Record<string, unknown>>(sql`SELECT g.id, g.symbol, g.name FROM drugs d CROSS JOIN LATERAL unnest(d.target_gene_ids) gid JOIN genes g ON g.id = gid WHERE d.id = ${id}`),
    ]);
    const data = {
      ...camel(drug[0]!),
      targets: camelRows(targets),
      aliases: camelRows(aliases),
      evidenceByCancer: evidence.map((r) => ({
        cancer: r.cancer_id ? { id: r.cancer_id, slug: r.cancer_slug, name: r.cancer_name } : null,
        diseaseName: r.disease_name,
        evidenceItems: num(r.evidence_items),
        byLevel: { A: num(r.level_a), B: num(r.level_b), C: num(r.level_c), DE: num(r.level_de) },
        byDirection: { supports: num(r.supports), doesNotSupport: num(r.does_not_support) },
        bySignificance: { sensitivity: num(r.sensitivity), resistance: num(r.resistance) },
        geneSymbols: r.gene_symbols ?? [],
        civicEvidenceIds: r.civic_ids,
        sourceId: r.source_id,
        category: 'curated_evidence',
      })),
      approvals: approvals.map((r) => {
        const { cancer_slug, cancer_name, source_url, retrieved_at, dataset_version, raw: _raw, provenance_id: _p, ...rest } = r;
        return { ...camel(rest), cancer: r.cancer_id ? { id: r.cancer_id, slug: cancer_slug, name: cancer_name } : null, provenance: { sourceId: r.source_id, url: source_url, retrievedAt: retrieved_at, datasetVersion: dataset_version, category: 'regulatory_status' } };
      }),
      trials: camelRows(trials),
    };
    return respond(app, data, [...pluck(aliases, 'source_id'), ...pluck(evidence, 'source_id'), ...pluck(approvals, 'source_id'), ...(trials.length ? ['clinicaltrials'] : [])]);
  });
};