/**
 * WordPress Site Registration Routes
 *
 * Manage registered WordPress installations
 */

import { Router, Request, Response } from 'express';
import { PrismaClient } from '@prisma/client';
import { z } from 'zod';
import { authenticateApiKey } from '../middleware/auth';
import { validate } from '../middleware/validator';
import { logger } from '../utils/logger';

const router = Router();
const prisma = new PrismaClient();

// Validation schemas
const siteRegisterSchema = z.object({
  siteUrl: z.string().url(),
  siteName: z.string().min(1).max(255),
  wpVersion: z.string().min(1).max(50),
  pluginVersion: z.string().min(1).max(50),
  phpVersion: z.string().optional(),
  activeTheme: z.string().optional(),
  locale: z.string().optional(),
  timezone: z.string().optional(),
  installedPlugins: z.array(z.object({
    name: z.string(),
    version: z.string(),
    active: z.boolean(),
  })).optional(),
});

const siteUpdateSchema = z.object({
  siteName: z.string().min(1).max(255).optional(),
  wpVersion: z.string().min(1).max(50).optional(),
  pluginVersion: z.string().min(1).max(50).optional(),
  phpVersion: z.string().optional(),
  activeTheme: z.string().optional(),
  locale: z.string().optional(),
  timezone: z.string().optional(),
  installedPlugins: z.array(z.object({
    name: z.string(),
    version: z.string(),
    active: z.boolean(),
  })).optional(),
  isActive: z.boolean().optional(),
});

/**
 * POST /v1/sites/register
 * Register a WordPress site
 *
 * @requires API Key authentication
 */
router.post(
  '/register',
  authenticateApiKey,
  validate(siteRegisterSchema),
  async (req: Request, res: Response) => {
    try {
      const userId = req.user!.userId;
      const siteData = req.body;

      logger.info('WordPress site registration request', {
        userId,
        siteUrl: siteData.siteUrl,
        wpVersion: siteData.wpVersion,
      });

      // Check if site already registered
      const existingSite = await prisma.wordPressSite.findFirst({
        where: {
          user_id: userId,
          site_url: siteData.siteUrl,
        },
      });

      let site;

      if (existingSite) {
        // Update existing site
        site = await prisma.wordPressSite.update({
          where: { id: existingSite.id },
          data: {
            site_name: siteData.siteName,
            wp_version: siteData.wpVersion,
            plugin_version: siteData.pluginVersion,
            php_version: siteData.phpVersion,
            active_theme: siteData.activeTheme,
            locale: siteData.locale,
            timezone: siteData.timezone,
            installed_plugins: siteData.installedPlugins as any,
            is_active: true,
            last_seen_at: new Date(),
          },
        });

        logger.info('WordPress site updated', {
          userId,
          siteId: site.id,
          siteUrl: site.site_url,
        });
      } else {
        // Create new site
        site = await prisma.wordPressSite.create({
          data: {
            user_id: userId,
            site_url: siteData.siteUrl,
            site_name: siteData.siteName,
            wp_version: siteData.wpVersion,
            plugin_version: siteData.pluginVersion,
            php_version: siteData.phpVersion,
            active_theme: siteData.activeTheme,
            locale: siteData.locale,
            timezone: siteData.timezone,
            installed_plugins: siteData.installedPlugins as any,
          },
        });

        logger.info('WordPress site registered', {
          userId,
          siteId: site.id,
          siteUrl: site.site_url,
        });
      }

      res.status(existingSite ? 200 : 201).json({
        success: true,
        siteId: site.id,
        message: existingSite ? 'Site updated successfully' : 'Site registered successfully',
        site: {
          id: site.id,
          siteUrl: site.site_url,
          siteName: site.site_name,
          wpVersion: site.wp_version,
          pluginVersion: site.plugin_version,
          isActive: site.is_active,
          createdAt: site.created_at.toISOString(),
          lastSeenAt: site.last_seen_at.toISOString(),
        },
      });
    } catch (error) {
      logger.error('Error registering WordPress site', { error, userId: req.user?.userId });
      res.status(500).json({
        error: true,
        code: 'SITE_REGISTRATION_FAILED',
        message: 'Failed to register WordPress site',
        timestamp: new Date().toISOString(),
      });
    }
  }
);

/**
 * GET /v1/sites
 * List registered WordPress sites for authenticated user
 *
 * @requires API Key authentication
 */
router.get(
  '/',
  authenticateApiKey,
  async (req: Request, res: Response) => {
    try {
      const userId = req.user!.userId;

      const sites = await prisma.wordPressSite.findMany({
        where: { user_id: userId },
        orderBy: { last_seen_at: 'desc' },
      });

      res.json({
        success: true,
        sites: sites.map(site => ({
          id: site.id,
          siteUrl: site.site_url,
          siteName: site.site_name,
          wpVersion: site.wp_version,
          pluginVersion: site.plugin_version,
          phpVersion: site.php_version,
          activeTheme: site.active_theme,
          locale: site.locale,
          timezone: site.timezone,
          isActive: site.is_active,
          createdAt: site.created_at.toISOString(),
          lastSeenAt: site.last_seen_at.toISOString(),
        })),
      });
    } catch (error) {
      logger.error('Error fetching WordPress sites', { error, userId: req.user?.userId });
      res.status(500).json({
        error: true,
        code: 'FETCH_SITES_FAILED',
        message: 'Failed to fetch WordPress sites',
        timestamp: new Date().toISOString(),
      });
    }
  }
);

/**
 * GET /v1/sites/:siteId
 * Get details of a specific WordPress site
 *
 * @requires API Key authentication
 */
router.get(
  '/:siteId',
  authenticateApiKey,
  async (req: Request, res: Response) => {
    try {
      const userId = req.user!.userId;
      const { siteId } = req.params;

      const site = await prisma.wordPressSite.findFirst({
        where: {
          id: siteId,
          user_id: userId,
        },
      });

      if (!site) {
        res.status(404).json({
          error: true,
          code: 'SITE_NOT_FOUND',
          message: 'WordPress site not found',
          timestamp: new Date().toISOString(),
        });
        return;
      }

      res.json({
        success: true,
        site: {
          id: site.id,
          siteUrl: site.site_url,
          siteName: site.site_name,
          wpVersion: site.wp_version,
          pluginVersion: site.plugin_version,
          phpVersion: site.php_version,
          activeTheme: site.active_theme,
          locale: site.locale,
          timezone: site.timezone,
          installedPlugins: site.installed_plugins,
          isActive: site.is_active,
          createdAt: site.created_at.toISOString(),
          lastSeenAt: site.last_seen_at.toISOString(),
        },
      });
    } catch (error) {
      logger.error('Error fetching WordPress site', { error, siteId: req.params.siteId });
      res.status(500).json({
        error: true,
        code: 'FETCH_SITE_FAILED',
        message: 'Failed to fetch WordPress site',
        timestamp: new Date().toISOString(),
      });
    }
  }
);

/**
 * PATCH /v1/sites/:siteId
 * Update WordPress site details
 *
 * @requires API Key authentication
 */
router.patch(
  '/:siteId',
  authenticateApiKey,
  validate(siteUpdateSchema),
  async (req: Request, res: Response) => {
    try {
      const userId = req.user!.userId;
      const { siteId } = req.params;
      const updates = req.body;

      // Verify ownership
      const site = await prisma.wordPressSite.findFirst({
        where: {
          id: siteId,
          user_id: userId,
        },
      });

      if (!site) {
        res.status(404).json({
          error: true,
          code: 'SITE_NOT_FOUND',
          message: 'WordPress site not found',
          timestamp: new Date().toISOString(),
        });
        return;
      }

      // Update site
      const updatedSite = await prisma.wordPressSite.update({
        where: { id: siteId },
        data: {
          ...(updates.siteName && { site_name: updates.siteName }),
          ...(updates.wpVersion && { wp_version: updates.wpVersion }),
          ...(updates.pluginVersion && { plugin_version: updates.pluginVersion }),
          ...(updates.phpVersion && { php_version: updates.phpVersion }),
          ...(updates.activeTheme && { active_theme: updates.activeTheme }),
          ...(updates.locale && { locale: updates.locale }),
          ...(updates.timezone && { timezone: updates.timezone }),
          ...(updates.installedPlugins && { installed_plugins: updates.installedPlugins as any }),
          ...(updates.isActive !== undefined && { is_active: updates.isActive }),
        },
      });

      logger.info('WordPress site updated', { userId, siteId });

      res.json({
        success: true,
        message: 'Site updated successfully',
        site: {
          id: updatedSite.id,
          siteUrl: updatedSite.site_url,
          siteName: updatedSite.site_name,
          wpVersion: updatedSite.wp_version,
          pluginVersion: updatedSite.plugin_version,
          isActive: updatedSite.is_active,
          lastSeenAt: updatedSite.last_seen_at.toISOString(),
        },
      });
    } catch (error) {
      logger.error('Error updating WordPress site', { error, siteId: req.params.siteId });
      res.status(500).json({
        error: true,
        code: 'UPDATE_SITE_FAILED',
        message: 'Failed to update WordPress site',
        timestamp: new Date().toISOString(),
      });
    }
  }
);

export default router;