/**
 * BrandKit Template Routes
 *
 * CRUD endpoints for BrandKitTemplate documents (template marketplace).
 * Mirrors the stationeryTemplates pattern — list strips HTML, detail returns full doc.
 */

import express, { Request, Response } from 'express';
import { body, query, validationResult } from 'express-validator';
import { getModels } from '../models';
import { authenticateJwtOrApiToken } from '../middleware/dualAuth';
import { requirePermission } from '../middleware/permissions';

const router = express.Router();

router.use(authenticateJwtOrApiToken);

// ── List templates (filtered by companyId for company templates, or global) ──
router.get('/:companyId', async (req: Request, res: Response) => {
  try {
    const { companyId } = req.params;
    const { assetType, kind, scope, status } = req.query;

    if (!req.user!.companyIds.includes(companyId) && req.user!.role !== 'admin') {
      res.status(403).json({ error: 'Access denied' });
      return;
    }

    const { BrandKitTemplate } = getModels();
    const filter: Record<string, any> = {
      $or: [{ companyId }, { scope: 'org' }, { scope: 'global' }],
    };
    if (assetType) filter.assetType = assetType as string;
    if (kind) filter.kind = kind as string;
    if (scope) filter.scope = scope as string;
    if (status) filter.status = status as string;

    // List view strips heavy HTML template field
    const templates = await (BrandKitTemplate as any)
      .find(filter)
      .select('-htmlTemplate -backHtmlTemplate -placeholders -backPlaceholders')
      .sort({ sortOrder: 1, createdAt: -1 });

    res.json(templates);
  } catch (error) {
    console.error('[BrandKitTemplate] List error:', error);
    res.status(500).json({ error: 'Failed to list templates' });
  }
});

// ── Get a single template (full document with HTML and placeholders) ──
router.get('/detail/:id', async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { BrandKitTemplate } = getModels();
    const template = await (BrandKitTemplate as any).findById(id);
    if (!template) {
      res.status(404).json({ error: 'Template not found' });
      return;
    }
    // Company-scoped templates require ownership
    if (template.companyId && template.scope === 'company') {
      if (!req.user!.companyIds.includes(template.companyId) && req.user!.role !== 'admin') {
        res.status(403).json({ error: 'Access denied' });
        return;
      }
    }
    res.json(template);
  } catch (error) {
    console.error('[BrandKitTemplate] Get error:', error);
    res.status(500).json({ error: 'Failed to get template' });
  }
});

// ── Create a template (admin or user-saved) ──
router.post(
  '/',
  requirePermission('brand-kit', 'create'),
  [
    body('name').notEmpty().withMessage('Template name is required'),
    body('assetType').notEmpty().withMessage('Asset type is required'),
  ],
  async (req: Request, res: Response) => {
    try {
      const errors = validationResult(req);
      if (!errors.isEmpty()) {
        res.status(400).json({ errors: errors.array() });
        return;
      }
      const { BrandKitTemplate } = getModels();
      const template = new (BrandKitTemplate as any)({
        ...req.body,
        kind: 'template', // AI generation removed — always 'template'
        source: req.body.source || 'user-saved',
      });
      await template.save();
      res.status(201).json(template);
    } catch (error) {
      console.error('[BrandKitTemplate] Create error:', error);
      res.status(500).json({ error: 'Failed to create template' });
    }
  }
);

// ── Update a template ──
router.put('/:id', requirePermission('brand-kit', 'edit'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { BrandKitTemplate } = getModels();
    const template = await (BrandKitTemplate as any).findById(id);
    if (!template) {
      res.status(404).json({ error: 'Template not found' });
      return;
    }
    // AI generation removed — force kind to 'template' for legacy records
    const updateData = { ...req.body, kind: 'template' };
    Object.assign(template, updateData);
    await template.save();
    res.json(template);
  } catch (error) {
    console.error('[BrandKitTemplate] Update error:', error);
    res.status(500).json({ error: 'Failed to update template' });
  }
});

// ── Duplicate a template ──
router.post('/duplicate/:id', requirePermission('brand-kit', 'create'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { companyId } = req.body;
    const { BrandKitTemplate } = getModels();
    const original = await (BrandKitTemplate as any).findById(id);
    if (!original) {
      res.status(404).json({ error: 'Template not found' });
      return;
    }
    const duplicate = new (BrandKitTemplate as any)({
      ...original.toObject(),
      _id: undefined,
      name: `${original.name} (Copy)`,
      companyId: companyId || original.companyId,
      kind: 'template', // AI generation removed — always 'template'
      source: 'user-saved',
      scope: 'company',
      status: 'draft',
    });
    await duplicate.save();
    res.status(201).json(duplicate);
  } catch (error) {
    console.error('[BrandKitTemplate] Duplicate error:', error);
    res.status(500).json({ error: 'Failed to duplicate template' });
  }
});

// ── Delete a template ──
router.delete('/:id', requirePermission('brand-kit', 'delete'), async (req: Request, res: Response) => {
  try {
    const { id } = req.params;
    const { BrandKitTemplate } = getModels();
    const template = await (BrandKitTemplate as any).findById(id);
    if (!template) {
      res.status(404).json({ error: 'Template not found' });
      return;
    }
    await (BrandKitTemplate as any).findByIdAndDelete(id);
    res.json({ message: 'Template deleted successfully' });
  } catch (error) {
    console.error('[BrandKitTemplate] Delete error:', error);
    res.status(500).json({ error: 'Failed to delete template' });
  }
});

export default router;