package com.codechecker.cache.schema;

import com.codechecker.cache.TestSupport;
import com.codechecker.cache.detector.RedisWritePointDetector;
import com.codechecker.cache.detector.WritePoint;
import com.codechecker.cache.diff.SchemaChange;
import com.codechecker.cache.diff.SchemaDiffer;
import org.junit.jupiter.api.Test;

import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

class SkeletonJsonRendererTest {

    @Test
    void rendersTenantVoThenEnvelopeSkeletons() {
        String tenantVo = TestSupport.fixture("fixtures/tenant/TenantVO.txt");
        String tenantLink = TestSupport.fixture("fixtures/tenant/TenantLinkModel.txt");
        String helperOld = TestSupport.fixture("fixtures/tenant/HelperOld.txt");
        String helperNew = TestSupport.fixture("fixtures/tenant/HelperNew.txt");

        Set<String> patterns = new HashSet<>();
        patterns.add("W01");
        patterns.add("W02");
        patterns.add("W03");

        SourceIndex oldIndex = new SourceIndex();
        oldIndex.addSource(tenantVo);
        oldIndex.addSource(tenantLink);
        oldIndex.addSource(helperOld);

        SourceIndex newIndex = new SourceIndex();
        newIndex.addSource(tenantVo);
        newIndex.addSource(tenantLink);
        newIndex.addSource(helperNew);

        WritePoint oldWp = new RedisWritePointDetector(oldIndex, patterns)
                .detect("Helper.java", helperOld).get(0);
        WritePoint newWp = new RedisWritePointDetector(newIndex, patterns)
                .detect("Helper.java", helperNew).get(0);

        TypeSchema oldSchema = new JavaSchemaExtractor(oldIndex, 8)
                .extract(oldWp.getResolvedValueType(), oldWp.isRootArray());
        TypeSchema newSchema = new JavaSchemaExtractor(newIndex, 8)
                .extract(newWp.getResolvedValueType(), newWp.isRootArray());

        List<SchemaChange> changes = new SchemaDiffer().diff(oldSchema, newSchema);
        Set<String> protectedPaths = changes.stream()
                .map(SchemaChange::getFieldPath)
                .filter(p -> p != null && !p.isEmpty())
                .collect(Collectors.toCollection(HashSet::new));
        changes.stream()
                .filter(c -> c.getOldValue() != null && c.getOldValue().contains("."))
                .forEach(c -> protectedPaths.add(c.getOldValue()));
        // also plain old paths without dot
        changes.forEach(c -> {
            if (c.getOldValue() != null && !c.getOldValue().isEmpty()
                    && c.getOldValue().indexOf(' ') < 0) {
                protectedPaths.add(c.getOldValue());
            }
        });

        SkeletonJsonRenderer renderer = new SkeletonJsonRenderer();
        String oldJson = renderer.render(oldSchema);
        String newJson = renderer.render(newSchema);

        assertTrue(oldJson.contains("\"dbName\":\"\""));
        assertTrue(oldJson.contains("\"linkList\":["));
        assertTrue(newJson.contains("\"vo\":{"));
        assertTrue(newJson.contains("\"expiresAtMs\":0"));
        assertTrue(newJson.contains("\"dbName\":\"\""));

        String truncated = renderer.render(newSchema, protectedPaths, 80);
        assertTrue(truncated.contains("expiresAtMs") || truncated.contains("vo"),
                "截断后仍应保留改动相关字段: " + truncated);
        assertEquals(true, truncated.length() >= 10);
    }
}