sam-manage/app/Http/Controllers/DevTools/FlowTesterController.php

<?php

namespace App\Http\Controllers\DevTools;

use App\Http\Controllers\Controller;
use App\Models\Admin\AdminApiFlow;
use App\Models\Admin\AdminApiFlowRun;
use App\Services\FlowTester\FlowExecutor;
use Illuminate\Http\Request;
use Illuminate\View\View;

/**
 * API Flow Tester Controller
 *
 * API 플로우 테스트 도구 컨트롤러
 */
class FlowTesterController extends Controller
{
    /**
     * 플로우 목록
     */
    public function index(): View
    {
        $flows = AdminApiFlow::with(['runs' => fn ($q) => $q->latest()->limit(1)])
            ->orderByDesc('created_at')
            ->paginate(20);

        return view('dev-tools.flow-tester.index', compact('flows'));
    }

    /**
     * 플로우 생성 폼
     */
    public function create(): View
    {
        return view('dev-tools.flow-tester.create');
    }

    /**
     * 플로우 저장
     */
    public function store(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:100',
            'description' => 'nullable|string',
            'category' => 'nullable|string|max:50',
            'flow_definition' => 'required|json',
        ]);

        $validated['flow_definition'] = json_decode($validated['flow_definition'], true);
        $validated['created_by'] = auth()->id();

        $flow = AdminApiFlow::create($validated);

        return redirect()
            ->route('dev-tools.flow-tester.edit', $flow->id)
            ->with('success', '플로우가 생성되었습니다.');
    }

    /**
     * 플로우 편집 폼
     */
    public function edit(int $id): View
    {
        $flow = AdminApiFlow::findOrFail($id);

        return view('dev-tools.flow-tester.edit', compact('flow'));
    }

    /**
     * 플로우 수정
     */
    public function update(Request $request, int $id)
    {
        $flow = AdminApiFlow::findOrFail($id);

        $validated = $request->validate([
            'name' => 'required|string|max:100',
            'description' => 'nullable|string',
            'category' => 'nullable|string|max:50',
            'flow_definition' => 'required|json',
            'is_active' => 'boolean',
        ]);

        $validated['flow_definition'] = json_decode($validated['flow_definition'], true);
        $validated['updated_by'] = auth()->id();

        $flow->update($validated);

        return redirect()
            ->route('dev-tools.flow-tester.edit', $flow->id)
            ->with('success', '플로우가 수정되었습니다.');
    }

    /**
     * 플로우 삭제
     */
    public function destroy(int $id)
    {
        $flow = AdminApiFlow::findOrFail($id);
        $flow->delete();

        return redirect()
            ->route('dev-tools.flow-tester.index')
            ->with('success', '플로우가 삭제되었습니다.');
    }

    /**
     * 플로우 복제
     */
    public function clone(int $id)
    {
        $original = AdminApiFlow::findOrFail($id);

        $clone = $original->replicate();
        $clone->name = $original->name.' (복사본)';
        $clone->created_by = auth()->id();
        $clone->updated_by = null;
        $clone->save();

        return redirect()
            ->route('dev-tools.flow-tester.edit', $clone->id)
            ->with('success', '플로우가 복제되었습니다.');
    }

    /**
     * JSON 유효성 검사 및 메타 정보 추출
     */
    public function validateJson(Request $request)
    {
        $json = $request->input('flow_definition', '');

        try {
            $data = json_decode($json, true, 512, JSON_THROW_ON_ERROR);

            // 기본 구조 검증
            $errors = [];

            if (! isset($data['steps']) || ! is_array($data['steps'])) {
                $errors[] = 'steps 배열이 필요합니다.';
            } else {
                foreach ($data['steps'] as $i => $step) {
                    if (empty($step['id'])) {
                        $errors[] = "steps[{$i}]: id가 필요합니다.";
                    }
                    if (empty($step['method'])) {
                        $errors[] = "steps[{$i}]: method가 필요합니다.";
                    }
                    if (empty($step['endpoint'])) {
                        $errors[] = "steps[{$i}]: endpoint가 필요합니다.";
                    }
                }
            }

            if (! empty($errors)) {
                return response()->json([
                    'valid' => false,
                    'errors' => $errors,
                ]);
            }

            // meta 정보 추출
            $meta = $data['meta'] ?? [];
            $tags = $meta['tags'] ?? [];

            // 카테고리 추론: tags[0] 또는 첫 번째 endpoint에서 추출
            $category = $tags[0] ?? null;
            if (! $category && ! empty($data['steps'])) {
                $firstEndpoint = $data['steps'][0]['endpoint'] ?? '';
                // /item-master/pages → item-master
                if (preg_match('#^/([^/]+)#', $firstEndpoint, $matches)) {
                    $category = $matches[1];
                }
            }

            // 이름 추론: meta.name 또는 description 첫 부분
            $name = $meta['name'] ?? null;
            if (! $name && ! empty($meta['description'])) {
                // 설명의 첫 번째 줄 또는 50자까지
                $name = mb_substr(strtok($meta['description'], "\n"), 0, 50);
            }

            return response()->json([
                'valid' => true,
                'stepCount' => count($data['steps'] ?? []),
                'extracted' => [
                    'name' => $name,
                    'description' => $meta['description'] ?? null,
                    'category' => $category,
                    'author' => $meta['author'] ?? null,
                    'tags' => $tags,
                    'version' => $data['version'] ?? '1.0',
                ],
            ]);
        } catch (\JsonException $e) {
            return response()->json([
                'valid' => false,
                'errors' => ['JSON 파싱 오류: '.$e->getMessage()],
            ]);
        }
    }

    /**
     * 플로우 실행
     */
    public function run(int $id)
    {
        $flow = AdminApiFlow::findOrFail($id);

        // 실행 기록 생성
        $run = AdminApiFlowRun::create([
            'flow_id' => $flow->id,
            'status' => AdminApiFlowRun::STATUS_RUNNING,
            'started_at' => now(),
            'total_steps' => $flow->step_count,
            'executed_by' => auth()->id(),
        ]);

        try {
            // FlowExecutor로 실제 실행
            $executor = new FlowExecutor;
            $result = $executor->execute($flow->flow_definition);

            // 실행 결과 저장
            $run->update([
                'status' => $result['status'],
                'completed_at' => now(),
                'duration_ms' => $result['duration'],
                'completed_steps' => $result['completedSteps'],
                'failed_step' => $result['failedStep'],
                'execution_log' => $result['executionLog'],
                'error_message' => $result['errorMessage'],
                'api_logs' => $result['apiLogs'] ?? [],
            ]);

            return response()->json([
                'success' => $result['status'] === 'SUCCESS',
                'run_id' => $run->id,
                'status' => $result['status'],
                'message' => $this->getResultMessage($result),
                'result' => $result,
            ]);
        } catch (\Exception $e) {
            // 예외 발생 시 실패 처리
            $run->update([
                'status' => AdminApiFlowRun::STATUS_FAILED,
                'completed_at' => now(),
                'error_message' => $e->getMessage(),
            ]);

            return response()->json([
                'success' => false,
                'run_id' => $run->id,
                'status' => 'FAILED',
                'message' => '실행 오류: '.$e->getMessage(),
            ], 500);
        }
    }

    /**
     * 실행 결과 메시지 생성
     */
    private function getResultMessage(array $result): string
    {
        return match ($result['status']) {
            'SUCCESS' => "플로우 실행 완료! ({$result['completedSteps']}/{$result['totalSteps']} 스텝 성공)",
            'FAILED' => '플로우 실행 실패: '.($result['errorMessage'] ?? '알 수 없는 오류'),
            'PARTIAL' => "부분 성공: {$result['completedSteps']}/{$result['totalSteps']} 스텝 완료",
            default => "실행 완료 (상태: {$result['status']})",
        };
    }

    /**
     * 실행 상태 조회 (Polling)
     */
    public function runStatus(int $runId)
    {
        $run = AdminApiFlowRun::findOrFail($runId);

        return response()->json([
            'status' => $run->status,
            'progress' => $run->progress,
            'completed_steps' => $run->completed_steps,
            'total_steps' => $run->total_steps,
            'is_completed' => $run->isCompleted(),
            'execution_log' => $run->execution_log,
        ]);
    }

    /**
     * 실행 이력 목록
     */
    public function history(int $id): View
    {
        $flow = AdminApiFlow::findOrFail($id);
        $runs = $flow->runs()
            ->orderByDesc('created_at')
            ->paginate(20);

        return view('dev-tools.flow-tester.history', compact('flow', 'runs'));
    }

    /**
     * 실행 상세 보기
     */
    public function runDetail(int $runId): View
    {
        $run = AdminApiFlowRun::with('flow')->findOrFail($runId);

        return view('dev-tools.flow-tester.run-detail', compact('run'));
    }
}