<?php

declare(strict_types=1);

namespace UseCases\Task;

// @responsibility: Speichert Task-Ergebnisse mit Token-Tracking

use Domain\Entity\TaskComment;
use Domain\Entity\TaskResult;
use Domain\Repository\TaskRepositoryInterface;
use Domain\ValueObject\AssigneeType;
use Infrastructure\Persistence\TaskCommentRepository;
use Infrastructure\Persistence\TaskResultRepository;

class SaveTaskResultUseCase
{
    public function __construct(
        private TaskRepositoryInterface $taskRepository,
        private TaskResultRepository $resultRepository,
        private TaskCommentRepository $commentRepository
    ) {
    }

    public function execute(int $taskId, array $data): TaskResult
    {
        $this->validate($data);

        $task = $this->taskRepository->find($taskId);
        if ($task === null) {
            throw new \InvalidArgumentException("Task {$taskId} not found");
        }

        $executorType = AssigneeType::from($data['executor_type']);

        $result = new TaskResult();
        $result->setTaskId($taskId);
        $result->setExecutor($data['executor']);
        $result->setExecutorType($executorType);

        if (isset($data['assignment_id'])) {
            $result->setAssignmentId((int) $data['assignment_id']);
        }

        if (isset($data['model_name'])) {
            $result->setModelName($data['model_name']);
        }

        if (isset($data['request'])) {
            $result->setRequest($data['request']);
        }

        if (isset($data['response'])) {
            $result->setResponse($data['response']);
        }

        if (isset($data['tokens_input'])) {
            $result->setTokensInput((int) $data['tokens_input']);
        }

        if (isset($data['tokens_output'])) {
            $result->setTokensOutput((int) $data['tokens_output']);
        }

        if (isset($data['duration_ms'])) {
            $result->setDurationMs((int) $data['duration_ms']);
        }

        if (isset($data['cost_usd'])) {
            $result->setCostUsd((float) $data['cost_usd']);
        }

        if (isset($data['error_message'])) {
            $result->setErrorMessage($data['error_message']);
        }

        if (isset($data['status'])) {
            $result->setStatus($data['status']);
        }

        if (!isset($data['tokens_input']) || !isset($data['tokens_output'])) {
            $result->estimateTokens();
        }

        $id = $this->resultRepository->save($result);
        $result->setId($id);

        $status = $result->getStatus() === 'success' ? 'erfolgreich' : 'mit Fehler';
        $comment = new TaskComment();
        $comment->setTaskId($taskId);
        $comment->setAuthor($result->getExecutor());
        $comment->setAuthorType($executorType->isAI() ? 'ai' : 'human');
        $comment->setCommentType('result');
        $comment->setContent("Ergebnis gespeichert ({$status})");
        $comment->setMetadata([
            'result_id' => $id,
            'model' => $result->getModelName(),
            'tokens_total' => $result->getTokensTotal(),
        ]);
        $this->commentRepository->save($comment);

        return $result;
    }

    private function validate(array $data): void
    {
        if (!isset($data['executor']) || $data['executor'] === '') {
            throw new \InvalidArgumentException('Executor is required');
        }

        if (!isset($data['executor_type']) || $data['executor_type'] === '') {
            throw new \InvalidArgumentException('Executor type is required');
        }

        try {
            AssigneeType::from($data['executor_type']);
        } catch (\ValueError $e) {
            throw new \InvalidArgumentException('Invalid executor type');
        }
    }
}