/**
 * Multilingual Press Zone - Licensing endpoints
 *
 * Base path (mounted in server.ts): /v1/multilingual/license
 */

import { Router, Request, Response } from 'express';
import { z } from 'zod';
import { validate } from '../middleware/validator';
import { errorResponse, successResponse } from '../utils/errorHandler';
import { activateLicense, deactivateLicense, validateLicense } from '../services/multilingualLicenseService';
import { createRateLimiter } from '../middleware/rateLimiter';

// Rate limiters for license endpoints
const licenseActivateRateLimiter = createRateLimiter(15 * 60 * 1000, 30); // 30 req / 15 min
const licenseValidateRateLimiter = createRateLimiter(15 * 60 * 1000, 100); // 100 req / 15 min

/**
 * Detect plugin type from the mount path.
 * /v1/multilingual/license → 'multilingual'
 * /v1/international/license → 'international'
 * Falls back to 'multilingual'.
 */
function getPluginFromRequest(req: Request): string {
  const base = req.baseUrl || '';
  if (base.includes('/international/')) return 'international';
  if (base.includes('/translate/')) return 'translate';
  return 'multilingual';
}

const router = Router();

const licenseKeySchema = z
  .string()
  .regex(/^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/, 'Invalid license key format');

const siteUrlSchema = z.string().url('site_url must be a valid URL');

const activateSchema = z.object({
  license_key: licenseKeySchema,
  site_url: siteUrlSchema,
  product: z.string().optional(),
  version: z.string().optional(),
});

const deactivateSchema = z.object({
  license_key: licenseKeySchema,
  site_url: siteUrlSchema,
  product: z.string().optional(),
});

const validateSchema = z.object({
  license_key: licenseKeySchema,
  site_url: siteUrlSchema,
  product: z.string().optional(),
});

export function mapServiceError(err: unknown): { status: number; body: any } {
  const code = err instanceof Error ? err.message : 'UNKNOWN_ERROR';
  switch (code) {
    case 'INVALID_LICENSE':
      return { status: 404, body: errorResponse('INVALID_LICENSE', 'The license key is invalid') };
    case 'LICENSE_EXPIRED':
      return { status: 403, body: errorResponse('LICENSE_EXPIRED', 'This license has expired') };
    case 'LICENSE_NOT_ACTIVE':
      return { status: 403, body: errorResponse('LICENSE_NOT_ACTIVE', 'This license is not active') };
    case 'SUBSCRIPTION_REQUIRED':
      return { status: 403, body: errorResponse('SUBSCRIPTION_REQUIRED', 'An active subscription is required') };
    case 'LICENSE_OWNER_AMBIGUOUS':
      return { status: 409, body: errorResponse('LICENSE_OWNER_AMBIGUOUS', 'The license owner could not be resolved') };
    case 'SITE_LIMIT_REACHED':
      return { status: 409, body: errorResponse('SITE_LIMIT_REACHED', 'This license has reached its site limit') };
    default:
      return { status: 500, body: errorResponse('INTERNAL_ERROR', 'Failed to process license request') };
  }
}

/**
 * POST /activate
 */
router.post('/activate', licenseActivateRateLimiter, validate(activateSchema), async (req: Request, res: Response) => {
  try {
    const info = await activateLicense({
      license_key: req.body.license_key,
      site_url: req.body.site_url,
      plugin: getPluginFromRequest(req),
    });
    return res.status(200).json(successResponse(info));
  } catch (err) {
    const mapped = mapServiceError(err);
    return res.status(mapped.status).json(mapped.body);
  }
});

/**
 * POST /deactivate
 */
router.post('/deactivate', licenseActivateRateLimiter, validate(deactivateSchema), async (req: Request, res: Response) => {
  try {
    await deactivateLicense({
      license_key: req.body.license_key,
      site_url: req.body.site_url,
      plugin: getPluginFromRequest(req),
    });
    return res.status(200).json(successResponse({ success: true }));
  } catch (err) {
    const mapped = mapServiceError(err);
    return res.status(mapped.status).json(mapped.body);
  }
});

/**
 * POST /validate
 */
router.post('/validate', licenseValidateRateLimiter, validate(validateSchema), async (req: Request, res: Response) => {
  try {
    const info = await validateLicense({
      license_key: req.body.license_key,
      site_url: req.body.site_url,
      plugin: getPluginFromRequest(req),
    });
    return res.status(200).json(successResponse(info));
  } catch (err) {
    const mapped = mapServiceError(err);
    return res.status(mapped.status).json(mapped.body);
  }
});

/**
 * POST /status
 */
router.post('/status', licenseValidateRateLimiter, validate(validateSchema), async (req: Request, res: Response) => {
  try {
    const info = await validateLicense({
      license_key: req.body.license_key,
      site_url: req.body.site_url,
      plugin: getPluginFromRequest(req),
    });
    return res.status(200).json(successResponse(info));
  } catch (err) {
    const mapped = mapServiceError(err);
    return res.status(mapped.status).json(mapped.body);
  }
});

/**
 * GET /status
 * Convenience endpoint for quick checks.
 */
router.get('/status', licenseValidateRateLimiter, async (req: Request, res: Response) => {
  const license_key = typeof req.query.license_key === 'string' ? req.query.license_key.trim() : '';
  const site_url = typeof req.query.site_url === 'string' ? req.query.site_url.trim() : '';

  // Playwright + operational checks: this endpoint must be callable without any params.
  if (!license_key && !site_url) {
    return res.status(200).json(successResponse({ ok: true }));
  }

  // If only one param is provided, do not hard-fail. Report validation state.
  if (!license_key || !site_url) {
    return res.status(200).json(
      successResponse({
        ok: true,
        validation: {
          ok: false,
          message: 'Provide both license_key and site_url to validate a license',
        },
      })
    );
  }

  const parsed = validateSchema.safeParse({ license_key, site_url });
  if (!parsed.success) {
    return res.status(200).json(
      successResponse({
        ok: true,
        validation: {
          ok: false,
          issues: parsed.error.issues.map((i) => ({ path: i.path.join('.'), message: i.message })),
        },
      })
    );
  }

  try {
    const info = await validateLicense({
      license_key: parsed.data.license_key,
      site_url: parsed.data.site_url,
      plugin: getPluginFromRequest(req),
    });
    return res.status(200).json(successResponse({
      ok: true,
      license: {
        status: info.status,
        valid: info.status === 'active',
      },
    }));
  } catch (err) {
    const mapped = mapServiceError(err);
    return res.status(mapped.status).json(mapped.body);
  }
});

export default router;