package com.superbiz.agent.service;

import com.superbiz.agent.domain.entity.CaseLibrary;
import com.superbiz.agent.domain.entity.DiagnosisRun;
import com.superbiz.agent.domain.entity.DiagnosisSession;
import com.superbiz.agent.domain.enums.SourceType;
import com.superbiz.agent.repository.CaseLibraryRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.test.util.ReflectionTestUtils;

import java.util.Optional;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

class CaseLibraryServiceTest {

    private final CaseLibraryRepository caseLibraryRepository = mock(CaseLibraryRepository.class);
    private final CaseLibraryService service = new CaseLibraryService();

    @BeforeEach
    void setUp() {
        ReflectionTestUtils.setField(service, "caseLibraryRepository", caseLibraryRepository);
    }

    @Test
    void createFromRunStoresRunIdAsDiagnosisIdAndUsesRunContent() {
        DiagnosisRun run = DiagnosisRun.builder()
                .sessionId("session-1")
                .runId("run-1")
                .query("payment timeout")
                .answer("redis timeout caused payment latency")
                .build();
        when(caseLibraryRepository.findByDiagnosisId("run-1")).thenReturn(Optional.empty());
        when(caseLibraryRepository.save(any(CaseLibrary.class))).thenAnswer(invocation -> invocation.getArgument(0));

        CaseLibrary saved = service.createFromRun(run);

        assertEquals("run-1", saved.getDiagnosisId());
        assertEquals("payment timeout", saved.getTitle());
        assertEquals("redis timeout caused payment latency", saved.getRootCause());
        assertEquals("redis timeout caused payment latency", saved.getSolution());
        assertEquals(SourceType.AUTO, saved.getSourceType());
        assertNotNull(saved.getCaseId());
    }

    @Test
    void createFromRunReusesExistingCaseForIdempotency() {
        DiagnosisRun run = DiagnosisRun.builder()
                .runId("run-existing")
                .query("query")
                .answer("answer")
                .build();
        CaseLibrary existing = CaseLibrary.builder()
                .caseId("case-existing")
                .diagnosisId("run-existing")
                .build();
        when(caseLibraryRepository.findByDiagnosisId("run-existing")).thenReturn(Optional.of(existing));

        CaseLibrary saved = service.createFromRun(run);

        assertEquals("case-existing", saved.getCaseId());
        verify(caseLibraryRepository, never()).save(any());
    }

    @Test
    void createFromSessionPreservesLegacySessionIdSemantics() {
        DiagnosisSession session = DiagnosisSession.builder()
                .sessionId("legacy-session")
                .query("legacy query")
                .answer("legacy answer")
                .build();
        when(caseLibraryRepository.findByDiagnosisId("legacy-session")).thenReturn(Optional.empty());
        when(caseLibraryRepository.save(any(CaseLibrary.class))).thenAnswer(invocation -> invocation.getArgument(0));

        service.createFromSession(session);

        ArgumentCaptor<CaseLibrary> captor = ArgumentCaptor.forClass(CaseLibrary.class);
        verify(caseLibraryRepository).save(captor.capture());
        assertEquals("legacy-session", captor.getValue().getDiagnosisId());
        assertEquals("legacy answer", captor.getValue().getRootCause());
    }
}