<?php

namespace App\Module\Cleanup\Controllers;

use App\Module\Cleanup\Services\CleanupService;
use App\Module\Cleanup\Models\CleanupPlan;
use App\Module\Cleanup\Models\CleanupTask;
use App\Module\Cleanup\Models\CleanupConfig;
use App\Module\Cleanup\Models\CleanupBackup;
use App\Module\Cleanup\Enums\PLAN_TYPE;
use App\Module\Cleanup\Enums\DATA_CATEGORY;
use App\Module\Cleanup\Enums\CLEANUP_TYPE;
use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;
use UCore\ControllerCore;

/**
 * 清理模块控制器
 * 
 * 提供清理模块的后台管理接口
 */
class CleanupController extends ControllerCore
{
    /**
     * 显示清理模块首页
     */
    public function index(): JsonResponse
    {
        try {
            $stats = CleanupService::getCleanupStats();
            $health = CleanupService::getSystemHealth();
            $recommendations = CleanupService::getRecommendedPlans();

            return $this->success([
                'stats' => $stats,
                'health' => $health,
                'recommendations' => $recommendations,
            ]);
        } catch (\Exception $e) {
            return $this->error('获取数据失败: ' . $e->getMessage());
        }
    }

    /**
     * 扫描数据表
     */
    public function scanTables(Request $request): JsonResponse
    {
        try {
            $forceRefresh = $request->boolean('force_refresh', false);
            $result = CleanupService::scanTables($forceRefresh);

            return $this->success($result, '表扫描完成');
        } catch (\Exception $e) {
            return $this->error('扫描失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取清理配置列表
     */
    public function getConfigs(Request $request): JsonResponse
    {
        try {
            $query = CleanupConfig::query();

            // 筛选条件
            if ($request->has('module')) {
                $query->byModule($request->input('module'));
            }
            if ($request->has('category')) {
                $query->byCategory($request->input('category'));
            }
            if ($request->has('enabled')) {
                $query->where('is_enabled', $request->boolean('enabled'));
            }
            if ($request->has('search')) {
                $query->searchTable($request->input('search'));
            }

            // 排序
            $query->orderByPriority();

            // 分页
            $configs = $query->paginate($request->input('per_page', 20));

            return $this->success($configs);
        } catch (\Exception $e) {
            return $this->error('获取配置失败: ' . $e->getMessage());
        }
    }

    /**
     * 更新清理配置
     */
    public function updateConfig(Request $request, int $id): JsonResponse
    {
        try {
            $config = CleanupConfig::findOrFail($id);
            
            $validated = $request->validate([
                'default_cleanup_type' => 'sometimes|integer|in:1,2,3,4,5',
                'default_conditions' => 'sometimes|array',
                'is_enabled' => 'sometimes|boolean',
                'priority' => 'sometimes|integer|min:1|max:999',
                'batch_size' => 'sometimes|integer|min:100|max:10000',
                'description' => 'sometimes|string|max:500',
            ]);

            $config->update($validated);

            return $this->success($config, '配置更新成功');
        } catch (\Exception $e) {
            return $this->error('更新配置失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取清理计划列表
     */
    public function getPlans(Request $request): JsonResponse
    {
        try {
            $query = CleanupPlan::with(['contents']);

            // 筛选条件
            if ($request->has('type')) {
                $query->byType($request->input('type'));
            }
            if ($request->has('enabled')) {
                $query->where('is_enabled', $request->boolean('enabled'));
            }
            if ($request->has('template')) {
                if ($request->boolean('template')) {
                    $query->templates();
                } else {
                    $query->nonTemplates();
                }
            }
            if ($request->has('search')) {
                $query->searchName($request->input('search'));
            }

            // 排序
            $query->orderBy('created_at', 'desc');

            // 分页
            $plans = $query->paginate($request->input('per_page', 20));

            return $this->success($plans);
        } catch (\Exception $e) {
            return $this->error('获取计划失败: ' . $e->getMessage());
        }
    }

    /**
     * 创建清理计划
     */
    public function createPlan(Request $request): JsonResponse
    {
        try {
            $validated = $request->validate([
                'plan_name' => 'required|string|max:100|unique:cleanup_plans',
                'plan_type' => 'required|integer|in:1,2,3,4,5',
                'target_selection' => 'sometimes|array',
                'global_conditions' => 'sometimes|array',
                'backup_config' => 'sometimes|array',
                'is_template' => 'sometimes|boolean',
                'is_enabled' => 'sometimes|boolean',
                'description' => 'sometimes|string|max:500',
            ]);

            $result = CleanupService::createCleanupPlan($validated);

            if ($result['success']) {
                return $this->success($result, '计划创建成功');
            } else {
                return $this->error($result['message']);
            }
        } catch (\Exception $e) {
            return $this->error('创建计划失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取计划详情
     */
    public function getPlan(int $id): JsonResponse
    {
        try {
            $plan = CleanupPlan::with(['contents', 'tasks', 'backups'])->findOrFail($id);
            return $this->success($plan);
        } catch (\Exception $e) {
            return $this->error('获取计划详情失败: ' . $e->getMessage());
        }
    }

    /**
     * 更新清理计划
     */
    public function updatePlan(Request $request, int $id): JsonResponse
    {
        try {
            $plan = CleanupPlan::findOrFail($id);
            
            $validated = $request->validate([
                'plan_name' => 'sometimes|string|max:100|unique:cleanup_plans,plan_name,' . $id,
                'target_selection' => 'sometimes|array',
                'global_conditions' => 'sometimes|array',
                'backup_config' => 'sometimes|array',
                'is_enabled' => 'sometimes|boolean',
                'description' => 'sometimes|string|max:500',
            ]);

            $plan->update($validated);

            return $this->success($plan, '计划更新成功');
        } catch (\Exception $e) {
            return $this->error('更新计划失败: ' . $e->getMessage());
        }
    }

    /**
     * 删除清理计划
     */
    public function deletePlan(int $id): JsonResponse
    {
        try {
            $plan = CleanupPlan::findOrFail($id);
            
            // 检查是否有正在运行的任务
            $runningTasks = $plan->tasks()->running()->count();
            if ($runningTasks > 0) {
                return $this->error('该计划有正在运行的任务，无法删除');
            }

            $plan->delete();

            return $this->success(null, '计划删除成功');
        } catch (\Exception $e) {
            return $this->error('删除计划失败: ' . $e->getMessage());
        }
    }

    /**
     * 生成计划内容
     */
    public function generatePlanContents(int $id): JsonResponse
    {
        try {
            $result = CleanupService::generatePlanContents($id);

            if ($result['success']) {
                return $this->success($result, '计划内容生成成功');
            } else {
                return $this->error($result['message']);
            }
        } catch (\Exception $e) {
            return $this->error('生成计划内容失败: ' . $e->getMessage());
        }
    }

    /**
     * 预览计划清理结果
     */
    public function previewPlan(int $id): JsonResponse
    {
        try {
            $result = CleanupService::previewPlanCleanup($id);
            return $this->success($result);
        } catch (\Exception $e) {
            return $this->error('预览失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取清理任务列表
     */
    public function getTasks(Request $request): JsonResponse
    {
        try {
            $query = CleanupTask::with(['plan']);

            // 筛选条件
            if ($request->has('plan_id')) {
                $query->byPlan($request->input('plan_id'));
            }
            if ($request->has('status')) {
                $query->byStatus($request->input('status'));
            }
            if ($request->has('search')) {
                $query->searchName($request->input('search'));
            }

            // 排序
            $query->orderBy('created_at', 'desc');

            // 分页
            $tasks = $query->paginate($request->input('per_page', 20));

            return $this->success($tasks);
        } catch (\Exception $e) {
            return $this->error('获取任务失败: ' . $e->getMessage());
        }
    }

    /**
     * 创建清理任务
     */
    public function createTask(Request $request): JsonResponse
    {
        try {
            $validated = $request->validate([
                'plan_id' => 'required|integer|exists:cleanup_plans,id',
                'task_name' => 'sometimes|string|max:100',
                'execute_immediately' => 'sometimes|boolean',
            ]);

            $result = CleanupService::createCleanupTask(
                $validated['plan_id'],
                $validated
            );

            if ($result['success']) {
                return $this->success($result, '任务创建成功');
            } else {
                return $this->error($result['message']);
            }
        } catch (\Exception $e) {
            return $this->error('创建任务失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取任务详情
     */
    public function getTask(int $id): JsonResponse
    {
        try {
            $task = CleanupTask::with(['plan', 'backup', 'logs'])->findOrFail($id);
            return $this->success($task);
        } catch (\Exception $e) {
            return $this->error('获取任务详情失败: ' . $e->getMessage());
        }
    }

    /**
     * 执行清理任务
     */
    public function executeTask(Request $request, int $id): JsonResponse
    {
        try {
            $dryRun = $request->boolean('dry_run', false);
            $result = CleanupService::executeCleanupTask($id, $dryRun);

            if ($result['success']) {
                return $this->success($result, '任务执行成功');
            } else {
                return $this->error($result['message']);
            }
        } catch (\Exception $e) {
            return $this->error('执行任务失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取任务进度
     */
    public function getTaskProgress(int $id): JsonResponse
    {
        try {
            $result = CleanupService::getTaskProgress($id);
            return $this->success($result);
        } catch (\Exception $e) {
            return $this->error('获取进度失败: ' . $e->getMessage());
        }
    }

    /**
     * 停止任务
     */
    public function stopTask(int $id): JsonResponse
    {
        try {
            $result = CleanupService::stopTask($id);

            if ($result['success']) {
                return $this->success($result, '任务已停止');
            } else {
                return $this->error($result['message']);
            }
        } catch (\Exception $e) {
            return $this->error('停止任务失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取备份列表
     */
    public function getBackups(Request $request): JsonResponse
    {
        try {
            $query = CleanupBackup::with(['plan', 'task']);

            // 筛选条件
            if ($request->has('plan_id')) {
                $query->byPlan($request->input('plan_id'));
            }
            if ($request->has('status')) {
                $query->byStatus($request->input('status'));
            }
            if ($request->has('search')) {
                $query->searchName($request->input('search'));
            }

            // 排序
            $query->orderBy('created_at', 'desc');

            // 分页
            $backups = $query->paginate($request->input('per_page', 20));

            return $this->success($backups);
        } catch (\Exception $e) {
            return $this->error('获取备份失败: ' . $e->getMessage());
        }
    }

    /**
     * 创建备份
     */
    public function createBackup(Request $request): JsonResponse
    {
        try {
            $validated = $request->validate([
                'plan_id' => 'required|integer|exists:cleanup_plans,id',
                'backup_type' => 'sometimes|integer|in:1,2,3',
                'compression_type' => 'sometimes|integer|in:1,2,3',
                'include_structure' => 'sometimes|boolean',
            ]);

            $result = CleanupService::createPlanBackup(
                $validated['plan_id'],
                $validated
            );

            if ($result['success']) {
                return $this->success($result, '备份创建成功');
            } else {
                return $this->error($result['message']);
            }
        } catch (\Exception $e) {
            return $this->error('创建备份失败: ' . $e->getMessage());
        }
    }

    /**
     * 获取枚举选项
     */
    public function getEnumOptions(): JsonResponse
    {
        try {
            return $this->success([
                'plan_types' => PLAN_TYPE::getDetailOptions(),
                'data_categories' => DATA_CATEGORY::getDetailOptions(),
                'cleanup_types' => CLEANUP_TYPE::getDetailOptions(),
            ]);
        } catch (\Exception $e) {
            return $this->error('获取选项失败: ' . $e->getMessage());
        }
    }
}