<?php

namespace App\Module\Cleanup\Services;

use App\Module\Cleanup\Logics\ModelScannerLogic;
use App\Module\Cleanup\Logics\CleanupPlanLogic;
use App\Module\Cleanup\Logics\CleanupTaskLogic;
use App\Module\Cleanup\Logics\CleanupExecutorLogic;
use App\Module\Cleanup\Logics\BackupLogic;
use App\Module\Cleanup\Models\CleanupPlan;
use App\Module\Cleanup\Models\CleanupTask;
use App\Module\Cleanup\Models\CleanupBackup;
use App\Module\Cleanup\Models\CleanupSqlBackup;

/**
 * 清理服务类
 * 
 * 提供对外的清理服务接口
 */
class CleanupService
{
    /**
     * 扫描Model类（推荐使用）
     *
     * @param bool $forceRefresh 是否强制刷新
     * @return array 扫描结果
     */
    public static function scanModels(bool $forceRefresh = false): array
    {
        return ModelScannerLogic::scanAllModels($forceRefresh);
    }

    /**
     * 扫描系统中的所有数据表（已废弃，建议使用scanModels）
     *
     * @deprecated 请使用 scanModels() 方法
     * @param bool $forceRefresh 是否强制刷新
     * @return array 扫描结果
     */
    public static function scanTables(bool $forceRefresh = false): array
    {
        // 为了向后兼容，重定向到新的Model扫描方法
        return static::scanModels($forceRefresh);
    }

    /**
     * 创建清理计划
     *
     * @param array $planData 计划数据
     * @return array 创建结果
     */
    public static function createCleanupPlan(array $planData): array
    {
        return CleanupPlanLogic::createPlan($planData);
    }

    /**
     * 为计划生成内容配置
     *
     * @param int $planId 计划ID
     * @param bool $autoGenerate 是否自动生成
     * @return array 生成结果
     */
    public static function generatePlanContents(int $planId, bool $autoGenerate = true): array
    {
        return CleanupPlanLogic::generateContents($planId, $autoGenerate);
    }

    /**
     * 基于计划创建清理任务
     *
     * @param int $planId 计划ID
     * @param array $taskOptions 任务选项
     * @return array 创建结果
     */
    public static function createCleanupTask(int $planId, array $taskOptions = []): array
    {
        return CleanupTaskLogic::createTask($planId, $taskOptions);
    }

    /**
     * 预览计划的清理结果
     *
     * @param int $planId 计划ID
     * @return array 预览结果
     */
    public static function previewPlanCleanup(int $planId): array
    {
        return CleanupExecutorLogic::previewPlanCleanup($planId);
    }

    /**
     * 预览任务的清理结果
     *
     * @param int $taskId 任务ID
     * @return array 预览结果
     */
    public static function previewTaskCleanup(int $taskId): array
    {
        return CleanupExecutorLogic::previewTaskCleanup($taskId);
    }

    /**
     * 执行清理任务
     *
     * @param int $taskId 任务ID
     * @param bool $dryRun 是否为预演模式
     * @return array 执行结果
     */
    public static function executeCleanupTask(int $taskId, bool $dryRun = false): array
    {
        return CleanupExecutorLogic::executeTask($taskId, $dryRun);
    }

    /**
     * 为计划创建数据备份
     *
     * @param int $planId 计划ID
     * @param array $backupOptions 备份选项
     * @return array 备份结果
     */
    public static function createPlanBackup(int $planId, array $backupOptions = []): array
    {
        return BackupLogic::createPlanBackup($planId, $backupOptions);
    }

    /**
     * 为任务创建数据备份
     *
     * @param int $taskId 任务ID
     * @param array $backupOptions 备份选项
     * @return array 备份结果
     */
    public static function createTaskBackup(int $taskId, array $backupOptions = []): array
    {
        return BackupLogic::createTaskBackup($taskId, $backupOptions);
    }

    /**
     * 恢复数据备份
     *
     * @param int $backupId 备份ID
     * @param array $restoreOptions 恢复选项
     * @return array 恢复结果
     */
    public static function restoreBackup(int $backupId, array $restoreOptions = []): array
    {
        return BackupLogic::restoreBackup($backupId, $restoreOptions);
    }

    /**
     * 验证备份完整性
     *
     * @param int $backupId 备份ID
     * @return array 验证结果
     */
    public static function verifyBackup(int $backupId): array
    {
        return BackupLogic::verifyBackup($backupId);
    }

    /**
     * 获取任务执行进度
     *
     * @param int $taskId 任务ID
     * @return array 进度信息
     */
    public static function getTaskProgress(int $taskId): array
    {
        try {
            return CleanupTaskLogic::getTaskProgress($taskId);
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '获取任务进度失败：' . $e->getMessage()
            ];
        }
    }

    /**
     * 停止任务执行
     *
     * @param int $taskId 任务ID
     * @return array 停止结果
     */
    public static function stopTask(int $taskId): array
    {
        try {
            return CleanupTaskLogic::stopTask($taskId);
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '停止任务失败：' . $e->getMessage()
            ];
        }
    }

    /**
     * 暂停任务执行
     *
     * @param int $taskId 任务ID
     * @return array 暂停结果
     */
    public static function pauseTask(int $taskId): array
    {
        try {
            return CleanupTaskLogic::pauseTask($taskId);
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '暂停任务失败：' . $e->getMessage()
            ];
        }
    }

    /**
     * 恢复任务执行
     *
     * @param int $taskId 任务ID
     * @return array 恢复结果
     */
    public static function resumeTask(int $taskId): array
    {
        try {
            return CleanupTaskLogic::resumeTask($taskId);
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '恢复任务失败：' . $e->getMessage()
            ];
        }
    }

    /**
     * 启动任务执行
     *
     * @param int $taskId 任务ID
     * @return array 启动结果
     */
    public static function startTask(int $taskId): array
    {
        try {
            return CleanupTaskLogic::startTask($taskId);
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '启动任务失败：' . $e->getMessage()
            ];
        }
    }

    /**
     * 取消任务执行
     *
     * @param int $taskId 任务ID
     * @param string $reason 取消原因
     * @return array 取消结果
     */
    public static function cancelTask(int $taskId, string $reason = ''): array
    {
        try {
            return CleanupTaskLogic::cancelTask($taskId, $reason);
        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '取消任务失败：' . $e->getMessage()
            ];
        }
    }

    /**
     * 获取清理统计信息
     *
     * @param array $filters 筛选条件
     * @return array 统计信息
     */
    public static function getCleanupStats(array $filters = []): array
    {
        return [
            'plans' => CleanupPlan::getEnabledStats(),
            'tasks' => CleanupTask::getStatusStats(),
            'backups' => CleanupBackup::getStatusStats(),
            'recent_tasks' => CleanupTask::getRecentStats(7),
            'storage' => CleanupBackup::getStorageStats(),
        ];
    }

    /**
     * 清理过期备份
     *
     * @param int $retentionDays 保留天数
     * @return array 清理结果
     */
    public static function cleanExpiredBackups(int $retentionDays = 30): array
    {
        return BackupLogic::cleanExpiredBackups($retentionDays);
    }

    /**
     * 获取SQL备份列表
     *
     * @param array $filters 筛选条件
     * @return array SQL备份列表
     */
    public static function getSqlBackups(array $filters = []): array
    {
        $query = CleanupSqlBackup::with('backup');

        // 按备份ID筛选
        if (!empty($filters['backup_id'])) {
            $query->where('backup_id', $filters['backup_id']);
        }

        // 按表名筛选
        if (!empty($filters['table_name'])) {
            $query->where('table_name', 'like', '%' . $filters['table_name'] . '%');
        }

        // 按记录数量筛选
        if (!empty($filters['min_records'])) {
            $query->where('records_count', '>=', $filters['min_records']);
        }

        // 按内容大小筛选
        if (!empty($filters['min_size'])) {
            $query->where('content_size', '>=', $filters['min_size']);
        }

        // 排序
        $orderBy = $filters['order_by'] ?? 'created_at';
        $orderDirection = $filters['order_direction'] ?? 'desc';
        $query->orderBy($orderBy, $orderDirection);

        // 分页
        $perPage = $filters['per_page'] ?? 20;
        $result = $query->paginate($perPage);

        return [
            'success' => true,
            'data' => $result->items(),
            'pagination' => [
                'current_page' => $result->currentPage(),
                'per_page' => $result->perPage(),
                'total' => $result->total(),
                'last_page' => $result->lastPage(),
            ]
        ];
    }

    /**
     * 获取SQL备份详情
     *
     * @param int $sqlBackupId SQL备份ID
     * @return array 备份详情
     */
    public static function getSqlBackupDetail(int $sqlBackupId): array
    {
        try {
            $sqlBackup = CleanupSqlBackup::with('backup')->findOrFail($sqlBackupId);

            return [
                'success' => true,
                'data' => [
                    'id' => $sqlBackup->id,
                    'backup_id' => $sqlBackup->backup_id,
                    'backup_name' => $sqlBackup->backup->backup_name ?? '',
                    'table_name' => $sqlBackup->table_name,
                    'records_count' => $sqlBackup->records_count,
                    'content_size' => $sqlBackup->content_size,
                    'formatted_size' => $sqlBackup->formatted_size,
                    'content_hash' => $sqlBackup->content_hash,
                    'sql_preview' => $sqlBackup->sql_preview,
                    'backup_conditions' => $sqlBackup->backup_conditions,
                    'created_at' => $sqlBackup->created_at,
                    'updated_at' => $sqlBackup->updated_at,
                ]
            ];

        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '获取SQL备份详情失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 获取SQL备份内容
     *
     * @param int $sqlBackupId SQL备份ID
     * @return array 备份内容
     */
    public static function getSqlBackupContent(int $sqlBackupId): array
    {
        try {
            $sqlBackup = CleanupSqlBackup::findOrFail($sqlBackupId);

            return [
                'success' => true,
                'data' => [
                    'id' => $sqlBackup->id,
                    'table_name' => $sqlBackup->table_name,
                    'sql_content' => $sqlBackup->sql_content,
                    'records_count' => $sqlBackup->records_count,
                    'content_size' => $sqlBackup->content_size,
                ]
            ];

        } catch (\Exception $e) {
            return [
                'success' => false,
                'message' => '获取SQL备份内容失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 清理历史日志
     *
     * @param int $retentionDays 保留天数
     * @return array 清理结果
     */
    public static function cleanHistoryLogs(int $retentionDays = 30): array
    {
        return CleanupTaskLogic::cleanHistoryLogs($retentionDays);
    }

    /**
     * 获取系统健康状态
     *
     * @return array 健康状态
     */
    public static function getSystemHealth(): array
    {
        $runningTasks = CleanupTask::running()->count();
        $failedTasks = CleanupTask::byStatus(\App\Module\Cleanup\Enums\TASK_STATUS::FAILED->value)
            ->where('created_at', '>=', now()->subDay())
            ->count();
        $expiredBackups = CleanupBackup::expired()->count();
        $expiringSoonBackups = CleanupBackup::expiringSoon(3)->count();

        $health = 'good';
        $issues = [];

        if ($runningTasks > 5) {
            $health = 'warning';
            $issues[] = "有 {$runningTasks} 个任务正在运行，可能存在性能问题";
        }

        if ($failedTasks > 0) {
            $health = 'warning';
            $issues[] = "最近24小时内有 {$failedTasks} 个任务执行失败";
        }

        if ($expiredBackups > 0) {
            $health = 'warning';
            $issues[] = "有 {$expiredBackups} 个备份已过期，建议清理";
        }

        if ($expiringSoonBackups > 0) {
            $issues[] = "有 {$expiringSoonBackups} 个备份即将过期";
        }

        if ($failedTasks > 5) {
            $health = 'critical';
        }

        return [
            'health' => $health,
            'issues' => $issues,
            'metrics' => [
                'running_tasks' => $runningTasks,
                'failed_tasks_24h' => $failedTasks,
                'expired_backups' => $expiredBackups,
                'expiring_soon_backups' => $expiringSoonBackups,
            ],
        ];
    }

    /**
     * 获取推荐的清理计划
     *
     * @return array 推荐计划
     */
    public static function getRecommendedPlans(): array
    {
        $recommendations = [];

        // 检查是否有大量日志数据
        $logTables = \App\Module\Cleanup\Models\CleanupConfig::byCategory(
            \App\Module\Cleanup\Enums\DATA_CATEGORY::LOG_DATA->value
        )->get();

        if ($logTables->count() > 0) {
            $recommendations[] = [
                'type' => 'category',
                'title' => '日志数据清理',
                'description' => '清理系统中的日志数据，释放存储空间',
                'config' => [
                    'plan_type' => \App\Module\Cleanup\Enums\PLAN_TYPE::CATEGORY->value,
                    'target_selection' => [
                        'selection_type' => 'category',
                        'categories' => [\App\Module\Cleanup\Enums\DATA_CATEGORY::LOG_DATA->value],
                    ],
                ],
                'estimated_tables' => $logTables->count(),
            ];
        }

        // 检查是否有缓存数据
        $cacheTables = \App\Module\Cleanup\Models\CleanupConfig::byCategory(
            \App\Module\Cleanup\Enums\DATA_CATEGORY::CACHE_DATA->value
        )->get();

        if ($cacheTables->count() > 0) {
            $recommendations[] = [
                'type' => 'category',
                'title' => '缓存数据清理',
                'description' => '清理系统中的缓存数据，提高系统性能',
                'config' => [
                    'plan_type' => \App\Module\Cleanup\Enums\PLAN_TYPE::CATEGORY->value,
                    'target_selection' => [
                        'selection_type' => 'category',
                        'categories' => [\App\Module\Cleanup\Enums\DATA_CATEGORY::CACHE_DATA->value],
                    ],
                ],
                'estimated_tables' => $cacheTables->count(),
            ];
        }

        return $recommendations;
    }
}