kknongchang_2506/app/Module/Cleanup/Logics/CleanupExecutorLogic.php

<?php

namespace App\Module\Cleanup\Logics;

use App\Module\Cleanup\Models\CleanupTask;
use App\Module\Cleanup\Models\CleanupPlan;
use App\Module\Cleanup\Models\CleanupPlanContent;
use App\Module\Cleanup\Models\CleanupLog;
use App\Module\Cleanup\Enums\TASK_STATUS;
use App\Module\Cleanup\Enums\CLEANUP_TYPE;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Schema;

/**
 * 清理执行逻辑类
 * 
 * 负责实际的数据清理执行操作
 */
class CleanupExecutorLogic
{
    /**
     * 预览计划的清理结果
     *
     * @param int $planId 计划ID
     * @return array 预览结果
     */
    public static function previewPlanCleanup(int $planId): array
    {
        try {
            $plan = CleanupPlan::with('contents')->findOrFail($planId);
            
            $previewData = [];
            $totalRecords = 0;
            $totalTables = 0;
            
            foreach ($plan->contents->where('is_enabled', true) as $content) {
                $tablePreview = static::previewTableCleanup($content);
                $previewData[] = $tablePreview;
                $totalRecords += $tablePreview['affected_records'];
                $totalTables++;
            }

            return [
                'success' => true,
                'data' => [
                    'plan' => [
                        'id' => $plan->id,
                        'plan_name' => $plan->plan_name,
                        'description' => $plan->description,
                    ],
                    'summary' => [
                        'total_tables' => $totalTables,
                        'total_records' => $totalRecords,
                        'estimated_time' => static::estimateExecutionTime($totalRecords),
                    ],
                    'tables' => $previewData,
                ]
            ];

        } catch (\Exception $e) {
            Log::error('预览计划清理失败', [
                'plan_id' => $planId,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'message' => '预览计划清理失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 预览任务的清理结果
     *
     * @param int $taskId 任务ID
     * @return array 预览结果
     */
    public static function previewTaskCleanup(int $taskId): array
    {
        try {
            $task = CleanupTask::with('plan.contents')->findOrFail($taskId);
            
            if (!$task->plan) {
                throw new \Exception('任务关联的计划不存在');
            }

            return static::previewPlanCleanup($task->plan->id);

        } catch (\Exception $e) {
            Log::error('预览任务清理失败', [
                'task_id' => $taskId,
                'error' => $e->getMessage()
            ]);

            return [
                'success' => false,
                'message' => '预览任务清理失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 执行清理任务
     *
     * @param int $taskId 任务ID
     * @param bool $dryRun 是否为预演模式
     * @return array 执行结果
     */
    public static function executeTask(int $taskId, bool $dryRun = false): array
    {
        try {
            $task = CleanupTask::with('plan.contents')->findOrFail($taskId);
            
            if (!$task->plan) {
                throw new \Exception('任务关联的计划不存在');
            }

            // 检查任务状态
            $currentStatus = TASK_STATUS::from($task->status);
            if ($currentStatus !== TASK_STATUS::PENDING) {
                throw new \Exception('任务状态不正确，无法执行');
            }

            if ($dryRun) {
                return static::previewTaskCleanup($taskId);
            }

            // 开始执行任务
            return static::executeTaskInternal($task);

        } catch (\Exception $e) {
            Log::error('执行清理任务失败', [
                'task_id' => $taskId,
                'dry_run' => $dryRun,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            return [
                'success' => false,
                'message' => '执行清理任务失败: ' . $e->getMessage(),
                'data' => null
            ];
        }
    }

    /**
     * 内部执行任务逻辑
     *
     * @param CleanupTask $task 任务对象
     * @return array 执行结果
     */
    private static function executeTaskInternal(CleanupTask $task): array
    {
        $startTime = microtime(true);
        $totalDeleted = 0;
        $processedTables = 0;
        $errors = [];

        try {
            // 更新任务状态为执行中
            CleanupTaskLogic::updateTaskStatus($task->id, TASK_STATUS::RUNNING, [
                'current_step' => '开始执行清理',
            ]);

            // 获取启用的内容配置
            $enabledContents = $task->plan->contents->where('is_enabled', true)->sortBy('priority');

            foreach ($enabledContents as $content) {
                try {
                    // 更新当前步骤
                    CleanupTaskLogic::updateTaskProgress(
                        $task->id,
                        $processedTables,
                        $totalDeleted,
                        "正在清理表: {$content->table_name}"
                    );

                    // 执行表清理
                    $result = static::executeTableCleanup($content, $task->id);
                    
                    if ($result['success']) {
                        $totalDeleted += $result['deleted_records'];
                        $processedTables++;
                    } else {
                        $errors[] = "表 {$content->table_name}: " . $result['message'];
                    }

                } catch (\Exception $e) {
                    $errors[] = "表 {$content->table_name}: " . $e->getMessage();
                    Log::error("清理表失败", [
                        'task_id' => $task->id,
                        'table_name' => $content->table_name,
                        'error' => $e->getMessage()
                    ]);
                }
            }

            $executionTime = round(microtime(true) - $startTime, 3);

            // 更新任务完成状态
            $finalStatus = empty($errors) ? TASK_STATUS::COMPLETED : TASK_STATUS::FAILED;
            CleanupTaskLogic::updateTaskStatus($task->id, $finalStatus, [
                'total_records' => $totalDeleted,
                'deleted_records' => $totalDeleted,
                'execution_time' => $executionTime,
                'error_message' => empty($errors) ? null : implode('; ', $errors),
                'current_step' => $finalStatus === TASK_STATUS::COMPLETED ? '清理完成' : '清理失败',
            ]);

            return [
                'success' => $finalStatus === TASK_STATUS::COMPLETED,
                'message' => $finalStatus === TASK_STATUS::COMPLETED ? '清理任务执行成功' : '清理任务执行完成，但有错误',
                'data' => [
                    'task_id' => $task->id,
                    'processed_tables' => $processedTables,
                    'total_tables' => $enabledContents->count(),
                    'deleted_records' => $totalDeleted,
                    'execution_time' => $executionTime,
                    'errors' => $errors,
                ]
            ];

        } catch (\Exception $e) {
            // 更新任务失败状态
            CleanupTaskLogic::updateTaskStatus($task->id, TASK_STATUS::FAILED, [
                'error_message' => $e->getMessage(),
                'execution_time' => round(microtime(true) - $startTime, 3),
                'current_step' => '执行失败',
            ]);

            throw $e;
        }
    }

    /**
     * 预览表清理
     *
     * @param CleanupPlanContent $content 计划内容
     * @return array 预览结果
     */
    private static function previewTableCleanup(CleanupPlanContent $content): array
    {
        try {
            $tableName = $content->table_name;
            $cleanupType = CLEANUP_TYPE::from($content->cleanup_type);
            
            // 检查表是否存在
            if (!Schema::hasTable($tableName)) {
                return [
                    'table_name' => $tableName,
                    'cleanup_type' => $cleanupType->getDescription(),
                    'affected_records' => 0,
                    'current_records' => 0,
                    'error' => '表不存在',
                ];
            }

            $currentRecords = DB::table($tableName)->count();
            $affectedRecords = static::calculateAffectedRecords($tableName, $cleanupType, $content->conditions);

            return [
                'table_name' => $tableName,
                'cleanup_type' => $cleanupType->getDescription(),
                'affected_records' => $affectedRecords,
                'current_records' => $currentRecords,
                'remaining_records' => $currentRecords - $affectedRecords,
                'conditions' => $content->conditions,
                'batch_size' => $content->batch_size,
                'backup_enabled' => $content->backup_enabled,
            ];

        } catch (\Exception $e) {
            return [
                'table_name' => $content->table_name,
                'cleanup_type' => CLEANUP_TYPE::from($content->cleanup_type)->getDescription(),
                'affected_records' => 0,
                'current_records' => 0,
                'error' => $e->getMessage(),
            ];
        }
    }

    /**
     * 计算受影响的记录数
     *
     * @param string $tableName 表名
     * @param CLEANUP_TYPE $cleanupType 清理类型
     * @param array $conditions 清理条件
     * @return int 受影响的记录数
     */
    private static function calculateAffectedRecords(string $tableName, CLEANUP_TYPE $cleanupType, array $conditions): int
    {
        switch ($cleanupType) {
            case CLEANUP_TYPE::TRUNCATE:
            case CLEANUP_TYPE::DELETE_ALL:
                return DB::table($tableName)->count();
                
            case CLEANUP_TYPE::DELETE_BY_TIME:
                return static::countByTimeCondition($tableName, $conditions);
                
            case CLEANUP_TYPE::DELETE_BY_USER:
                return static::countByUserCondition($tableName, $conditions);
                
            case CLEANUP_TYPE::DELETE_BY_CONDITION:
                return static::countByCustomCondition($tableName, $conditions);
                
            default:
                return 0;
        }
    }

    /**
     * 按时间条件统计记录数
     *
     * @param string $tableName 表名
     * @param array $conditions 条件
     * @return int 记录数
     */
    private static function countByTimeCondition(string $tableName, array $conditions): int
    {
        $query = DB::table($tableName);
        
        if (!empty($conditions['time_field']) && !empty($conditions['before'])) {
            $timeField = $conditions['time_field'];
            $beforeTime = static::parseTimeCondition($conditions['before']);
            $query->where($timeField, '<', $beforeTime);
        }
        
        return $query->count();
    }

    /**
     * 按用户条件统计记录数
     *
     * @param string $tableName 表名
     * @param array $conditions 条件
     * @return int 记录数
     */
    private static function countByUserCondition(string $tableName, array $conditions): int
    {
        $query = DB::table($tableName);
        
        if (!empty($conditions['user_field']) && !empty($conditions['user_ids'])) {
            $userField = $conditions['user_field'];
            $userIds = is_array($conditions['user_ids']) ? $conditions['user_ids'] : [$conditions['user_ids']];
            $query->whereIn($userField, $userIds);
        }
        
        return $query->count();
    }

    /**
     * 按自定义条件统计记录数
     *
     * @param string $tableName 表名
     * @param array $conditions 条件
     * @return int 记录数
     */
    private static function countByCustomCondition(string $tableName, array $conditions): int
    {
        $query = DB::table($tableName);
        
        if (!empty($conditions['where'])) {
            foreach ($conditions['where'] as $condition) {
                if (isset($condition['field'], $condition['operator'], $condition['value'])) {
                    $query->where($condition['field'], $condition['operator'], $condition['value']);
                }
            }
        }
        
        return $query->count();
    }

    /**
     * 解析时间条件
     *
     * @param string $timeCondition 时间条件
     * @return string 解析后的时间
     */
    private static function parseTimeCondition(string $timeCondition): string
    {
        // 支持格式：30_days_ago, 1_month_ago, 2024-01-01, 等
        if (preg_match('/(\d+)_days?_ago/', $timeCondition, $matches)) {
            return now()->subDays((int)$matches[1])->toDateTimeString();
        }
        
        if (preg_match('/(\d+)_months?_ago/', $timeCondition, $matches)) {
            return now()->subMonths((int)$matches[1])->toDateTimeString();
        }
        
        if (preg_match('/(\d+)_years?_ago/', $timeCondition, $matches)) {
            return now()->subYears((int)$matches[1])->toDateTimeString();
        }
        
        // 直接返回时间字符串
        return $timeCondition;
    }

    /**
     * 估算执行时间
     *
     * @param int $totalRecords 总记录数
     * @return string 估算时间
     */
    private static function estimateExecutionTime(int $totalRecords): string
    {
        // 简单估算：每秒处理1000条记录
        $seconds = ceil($totalRecords / 1000);
        
        if ($seconds < 60) {
            return "{$seconds}秒";
        } elseif ($seconds < 3600) {
            $minutes = ceil($seconds / 60);
            return "{$minutes}分钟";
        } else {
            $hours = ceil($seconds / 3600);
            return "{$hours}小时";
        }
    }

    /**
     * 执行表清理
     *
     * @param CleanupPlanContent $content 计划内容
     * @param int $taskId 任务ID
     * @return array 执行结果
     */
    private static function executeTableCleanup(CleanupPlanContent $content, int $taskId): array
    {
        $startTime = microtime(true);
        $tableName = $content->table_name;
        $cleanupType = CLEANUP_TYPE::from($content->cleanup_type);

        try {
            // 检查表是否存在
            if (!Schema::hasTable($tableName)) {
                throw new \Exception("表 {$tableName} 不存在");
            }

            // 记录清理前的记录数
            $beforeCount = DB::table($tableName)->count();

            // 执行清理
            $deletedRecords = static::performCleanup($tableName, $cleanupType, $content->conditions, $content->batch_size);

            // 记录清理后的记录数
            $afterCount = DB::table($tableName)->count();
            $actualDeleted = $beforeCount - $afterCount;

            $executionTime = round(microtime(true) - $startTime, 3);

            // 记录清理日志
            static::logCleanupOperation($taskId, $tableName, $cleanupType, [
                'before_count' => $beforeCount,
                'after_count' => $afterCount,
                'deleted_records' => $actualDeleted,
                'execution_time' => $executionTime,
                'conditions' => $content->conditions,
                'batch_size' => $content->batch_size,
            ]);

            return [
                'success' => true,
                'message' => "表 {$tableName} 清理成功",
                'deleted_records' => $actualDeleted,
                'execution_time' => $executionTime,
            ];

        } catch (\Exception $e) {
            $executionTime = round(microtime(true) - $startTime, 3);

            // 记录错误日志
            static::logCleanupOperation($taskId, $tableName, $cleanupType, [
                'error' => $e->getMessage(),
                'execution_time' => $executionTime,
                'conditions' => $content->conditions,
            ]);

            return [
                'success' => false,
                'message' => $e->getMessage(),
                'deleted_records' => 0,
                'execution_time' => $executionTime,
            ];
        }
    }

    /**
     * 执行实际的清理操作
     *
     * @param string $tableName 表名
     * @param CLEANUP_TYPE $cleanupType 清理类型
     * @param array $conditions 清理条件
     * @param int $batchSize 批处理大小
     * @return int 删除的记录数
     */
    private static function performCleanup(string $tableName, CLEANUP_TYPE $cleanupType, array $conditions, int $batchSize): int
    {
        switch ($cleanupType) {
            case CLEANUP_TYPE::TRUNCATE:
                return static::performTruncate($tableName);

            case CLEANUP_TYPE::DELETE_ALL:
                return static::performDeleteAll($tableName, $batchSize);

            case CLEANUP_TYPE::DELETE_BY_TIME:
                return static::performDeleteByTime($tableName, $conditions, $batchSize);

            case CLEANUP_TYPE::DELETE_BY_USER:
                return static::performDeleteByUser($tableName, $conditions, $batchSize);

            case CLEANUP_TYPE::DELETE_BY_CONDITION:
                return static::performDeleteByCondition($tableName, $conditions, $batchSize);

            default:
                throw new \Exception("不支持的清理类型: {$cleanupType->value}");
        }
    }

    /**
     * 执行TRUNCATE操作
     *
     * @param string $tableName 表名
     * @return int 删除的记录数
     */
    private static function performTruncate(string $tableName): int
    {
        $beforeCount = DB::table($tableName)->count();
        DB::statement("TRUNCATE TABLE `{$tableName}`");
        return $beforeCount;
    }

    /**
     * 执行DELETE ALL操作
     *
     * @param string $tableName 表名
     * @param int $batchSize 批处理大小
     * @return int 删除的记录数
     */
    private static function performDeleteAll(string $tableName, int $batchSize): int
    {
        $totalDeleted = 0;

        do {
            $deleted = DB::table($tableName)->limit($batchSize)->delete();
            $totalDeleted += $deleted;
        } while ($deleted > 0);

        return $totalDeleted;
    }

    /**
     * 执行按时间删除操作
     *
     * @param string $tableName 表名
     * @param array $conditions 条件
     * @param int $batchSize 批处理大小
     * @return int 删除的记录数
     */
    private static function performDeleteByTime(string $tableName, array $conditions, int $batchSize): int
    {
        if (empty($conditions['time_field']) || empty($conditions['before'])) {
            throw new \Exception('时间删除条件不完整');
        }

        $timeField = $conditions['time_field'];
        $beforeTime = static::parseTimeCondition($conditions['before']);
        $totalDeleted = 0;

        do {
            $deleted = DB::table($tableName)
                ->where($timeField, '<', $beforeTime)
                ->limit($batchSize)
                ->delete();
            $totalDeleted += $deleted;
        } while ($deleted > 0);

        return $totalDeleted;
    }

    /**
     * 执行按用户删除操作
     *
     * @param string $tableName 表名
     * @param array $conditions 条件
     * @param int $batchSize 批处理大小
     * @return int 删除的记录数
     */
    private static function performDeleteByUser(string $tableName, array $conditions, int $batchSize): int
    {
        if (empty($conditions['user_field']) || empty($conditions['user_ids'])) {
            throw new \Exception('用户删除条件不完整');
        }

        $userField = $conditions['user_field'];
        $userIds = is_array($conditions['user_ids']) ? $conditions['user_ids'] : [$conditions['user_ids']];
        $totalDeleted = 0;

        do {
            $deleted = DB::table($tableName)
                ->whereIn($userField, $userIds)
                ->limit($batchSize)
                ->delete();
            $totalDeleted += $deleted;
        } while ($deleted > 0);

        return $totalDeleted;
    }

    /**
     * 执行按条件删除操作
     *
     * @param string $tableName 表名
     * @param array $conditions 条件
     * @param int $batchSize 批处理大小
     * @return int 删除的记录数
     */
    private static function performDeleteByCondition(string $tableName, array $conditions, int $batchSize): int
    {
        if (empty($conditions['where'])) {
            throw new \Exception('自定义删除条件不完整');
        }

        $totalDeleted = 0;

        do {
            $query = DB::table($tableName);

            foreach ($conditions['where'] as $condition) {
                if (isset($condition['field'], $condition['operator'], $condition['value'])) {
                    $query->where($condition['field'], $condition['operator'], $condition['value']);
                }
            }

            $deleted = $query->limit($batchSize)->delete();
            $totalDeleted += $deleted;
        } while ($deleted > 0);

        return $totalDeleted;
    }

    /**
     * 记录清理操作日志
     *
     * @param int $taskId 任务ID
     * @param string $tableName 表名
     * @param CLEANUP_TYPE $cleanupType 清理类型
     * @param array $details 详细信息
     */
    private static function logCleanupOperation(int $taskId, string $tableName, CLEANUP_TYPE $cleanupType, array $details): void
    {
        try {
            CleanupLog::create([
                'task_id' => $taskId,
                'table_name' => $tableName,
                'cleanup_type' => $cleanupType->value,
                'before_count' => $details['before_count'] ?? 0,
                'after_count' => $details['after_count'] ?? 0,
                'deleted_records' => $details['deleted_records'] ?? 0,
                'execution_time' => $details['execution_time'] ?? 0,
                'conditions' => $details['conditions'] ?? [],
                'error_message' => $details['error'] ?? null,
                'created_at' => now(),
            ]);
        } catch (\Exception $e) {
            Log::error('记录清理日志失败', [
                'task_id' => $taskId,
                'table_name' => $tableName,
                'error' => $e->getMessage()
            ]);
        }
    }
}