const express = require('express');
const { Subscription } = require('../models');
const MultiSubscriptionManager = require('../core/multiSubscriptionManager');
const logger = require('../utils/logger');

const router = express.Router();
const subscriptionManager = new MultiSubscriptionManager();

/**
 * 获取所有订阅列表
 */
router.get('/subscriptions', async (req, res) => {
  try {
    const subscriptions = await Subscription.findAll({
      order: [['createdAt', 'DESC']]
    });

    res.json({
      success: true,
      data: subscriptions
    });
  } catch (error) {
    logger.error('获取订阅列表失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 获取单个订阅详情
 */
router.get('/subscriptions/:id', async (req, res) => {
  try {
    const subscription = await Subscription.findByPk(req.params.id);
    
    if (!subscription) {
      return res.status(404).json({
        success: false,
        error: '订阅不存在'
      });
    }

    res.json({
      success: true,
      data: subscription
    });
  } catch (error) {
    logger.error('获取订阅详情失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 创建新订阅
 */
router.post('/subscriptions', async (req, res) => {
  try {
    const { name, url, description, speedTestConfig, notifyConfig } = req.body;

    if (!name || !url) {
      return res.status(400).json({
        success: false,
        error: '订阅名称和URL不能为空'
      });
    }

    // 检查URL是否已存在
    const existingSubscription = await Subscription.findOne({
      where: { url }
    });

    if (existingSubscription) {
      return res.status(400).json({
        success: false,
        error: '该订阅URL已存在'
      });
    }

    const subscription = await Subscription.create({
      name,
      url,
      description,
      speedTestConfig: speedTestConfig || {
        testCount: 3,
        timeout: 10000,
        testUrls: ['https://www.google.com', 'https://www.youtube.com'],
        speedTestEnabled: true
      },
      notifyConfig: notifyConfig || {
        enabled: true,
        notifyOnSpeedTest: true,
        notifyOnNodeUpdate: true,
        webhookUrl: '',
        emailConfig: null
      }
    });

    logger.info('创建新订阅成功', { 
      subscriptionId: subscription.id,
      subscriptionName: subscription.name 
    });

    res.status(201).json({
      success: true,
      data: subscription
    });
  } catch (error) {
    logger.error('创建订阅失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 更新订阅
 */
router.put('/subscriptions/:id', async (req, res) => {
  try {
    const subscription = await Subscription.findByPk(req.params.id);
    
    if (!subscription) {
      return res.status(404).json({
        success: false,
        error: '订阅不存在'
      });
    }

    const { name, url, description, speedTestConfig, notifyConfig, isActive } = req.body;

    // 如果更新URL，检查是否与其他订阅冲突
    if (url && url !== subscription.url) {
      const existingSubscription = await Subscription.findOne({
        where: { 
          url,
          id: { [require('sequelize').Op.ne]: req.params.id }
        }
      });

      if (existingSubscription) {
        return res.status(400).json({
          success: false,
          error: '该订阅URL已被其他订阅使用'
        });
      }
    }

    await subscription.update({
      name: name || subscription.name,
      url: url || subscription.url,
      description: description !== undefined ? description : subscription.description,
      speedTestConfig: speedTestConfig || subscription.speedTestConfig,
      notifyConfig: notifyConfig || subscription.notifyConfig,
      isActive: isActive !== undefined ? isActive : subscription.isActive
    });

    logger.info('更新订阅成功', { 
      subscriptionId: subscription.id,
      subscriptionName: subscription.name 
    });

    res.json({
      success: true,
      data: subscription
    });
  } catch (error) {
    logger.error('更新订阅失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 删除订阅
 */
router.delete('/subscriptions/:id', async (req, res) => {
  try {
    const subscription = await Subscription.findByPk(req.params.id);
    
    if (!subscription) {
      return res.status(404).json({
        success: false,
        error: '订阅不存在'
      });
    }

    await subscription.destroy();

    logger.info('删除订阅成功', { 
      subscriptionId: subscription.id,
      subscriptionName: subscription.name 
    });

    res.json({
      success: true,
      message: '订阅删除成功'
    });
  } catch (error) {
    logger.error('删除订阅失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 手动更新所有订阅
 */
router.post('/subscriptions/update-all', async (req, res) => {
  try {
    const result = await subscriptionManager.manualUpdate();
    
    if (result.success) {
      logger.info('手动更新所有订阅成功', { results: result.data });
      res.json({
        success: true,
        data: result.data
      });
    } else {
      logger.error('手动更新所有订阅失败', { error: result.error });
      res.status(500).json({
        success: false,
        error: result.error
      });
    }
  } catch (error) {
    logger.error('手动更新所有订阅失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 手动更新单个订阅
 */
router.post('/subscriptions/:id/update', async (req, res) => {
  try {
    const result = await subscriptionManager.manualUpdateSubscription(req.params.id);
    
    if (result.success) {
      logger.info('手动更新订阅成功', { 
        subscriptionId: req.params.id,
        result: result.data 
      });
      res.json({
        success: true,
        data: result.data
      });
    } else {
      logger.error('手动更新订阅失败', { 
        subscriptionId: req.params.id,
        error: result.error 
      });
      res.status(500).json({
        success: false,
        error: result.error
      });
    }
  } catch (error) {
    logger.error('手动更新订阅失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 获取订阅状态
 */
router.get('/subscriptions/status', async (req, res) => {
  try {
    const status = await subscriptionManager.getStatus();
    
    res.json({
      success: true,
      data: status
    });
  } catch (error) {
    logger.error('获取订阅状态失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 启动自动更新
 */
router.post('/subscriptions/start-auto-update', async (req, res) => {
  try {
    subscriptionManager.startAutoUpdate();
    
    logger.info('启动订阅自动更新成功');
    res.json({
      success: true,
      message: '订阅自动更新已启动'
    });
  } catch (error) {
    logger.error('启动订阅自动更新失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

/**
 * 停止自动更新
 */
router.post('/subscriptions/stop-auto-update', async (req, res) => {
  try {
    subscriptionManager.stopAutoUpdate();
    
    logger.info('停止订阅自动更新成功');
    res.json({
      success: true,
      message: '订阅自动更新已停止'
    });
  } catch (error) {
    logger.error('停止订阅自动更新失败', { error: error.message });
    res.status(500).json({
      success: false,
      error: error.message
    });
  }
});

module.exports = router;