package jnpf.limsService.provider;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import jnpf.audit.sdk.annotation.AuditLog;
import jnpf.exception.DataException;
import jnpf.lims.api.model.ElnSourceReference;
import lombok.Data;
import lombok.Value;

import java.time.Instant;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.function.Supplier;
import java.util.stream.Collectors;

/** Configuration writes and authorized business-data reads use separate adapters. */
public class LimsElnSourceCatalog {
    private final Store store;
    private final Supplier<Actor> actors;
    private final SourceReader reader;
    private final ObjectMapper json = new ObjectMapper();

    public LimsElnSourceCatalog(Store store, Supplier<Actor> actors) {
        this(store, actors, (definition, actor, sampleId) -> {
            throw new DataException("Source preview is unavailable");
        });
    }

    public LimsElnSourceCatalog(Store store, Supplier<Actor> actors, SourceReader reader) {
        this.store = store;
        this.actors = actors;
        this.reader = reader;
    }

    @AuditLog(action = "ELN_SOURCE_DRAFT_CREATE", bizType = "ELN_SOURCE",
            bizCodeExpr = "#result?.propertyCode", bizCodeRequired = false,
            targetTable = "lims_eln_provider_property_version", targetIdExpr = "#result?.id")
    public Version createDraft(Draft draft) {
        Actor actor = requireManager();
        if (draft == null || draft.getPropertyCode() == null
                || !draft.getPropertyCode().matches("[a-zA-Z][a-zA-Z0-9_.-]{0,79}")) {
            throw new DataException("Invalid source property code");
        }
        validateMetadata(draft);
        if (store.list(actor.getTenantId()).stream()
                .anyMatch(v -> draft.getPropertyCode().equals(v.getPropertyCode()))) {
            throw new DataException("Source property already exists");
        }
        Version version = new Version(UUID.randomUUID().toString(), actor.getTenantId(),
                draft.getPropertyCode(), 1, "DRAFT", draft.getDisplayName(), draft.getDataType(),
                encode(draft.getDefinition()), null, null, null, null, 0);
        store.insert(version);
        return version;
    }

    @AuditLog(action = "ELN_SOURCE_PUBLISH", failureAction = "ELN_SOURCE_PUBLISH_FAILED",
            bizType = "ELN_SOURCE", bizCodeExpr = "#result?.propertyCode", bizCodeRequired = false,
            targetTable = "lims_eln_provider_property_version", targetIdExpr = "#id")
    public Version publish(String id, int expectedEditVersion, String sampleId) {
        Actor actor = requireManager();
        Version draft = detail(id);
        if (!"DRAFT".equals(draft.getStatus())) throw new DataException("Published source is immutable");
        if (draft.getEditVersion() != expectedEditVersion) throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_CONFLICT", "Source version has changed");
        if (sampleId == null || sampleId.trim().isEmpty()) {
            throw new DataException("An authorized preview sample is required");
        }
        Preview preview = reader.read(decode(draft.getDefinitionJson()), actor, sampleId);
        if (preview == null || preview.getValues() == null || preview.getValues().size() != 1
                || preview.getValues().get(0) == null
                || preview.getValues().get(0) instanceof String
                    && ((String) preview.getValues().get(0)).trim().isEmpty()) {
            throw new DataException("Source preview must resolve one value");
        }
        if (!matchesType(draft.getDataType(), preview.getValues().get(0))) {
            throw new DataException("Source preview type does not match");
        }
        try {
            JsonNode frozen = preview.getFrozenDefinitionJson() == null
                    ? null : json.readTree(preview.getFrozenDefinitionJson());
            if (frozen == null || !frozen.isObject() || frozen.isEmpty()) {
                throw new DataException("A complete resolved definition is required");
            }
        } catch (JsonProcessingException e) {
            throw new DataException("Resolved source definition is invalid");
        }
        Version published = new Version(draft.getId(), draft.getTenantId(), draft.getPropertyCode(),
                draft.getRevision(), "PUBLISHED", draft.getDisplayName(), draft.getDataType(),
                draft.getDefinitionJson(), preview.getFrozenDefinitionJson(), sampleId,
                actor.getUserId(), Instant.now().toString(), draft.getEditVersion() + 1);
        if (!store.replaceDraft(draft, published)) throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_CONFLICT", "Source version has changed");
        return published;
    }

    public Preview preview(String id, String sampleId) {
        Actor actor = requireManager();
        Version version = detail(id);
        if (sampleId == null || sampleId.trim().isEmpty()) {
            throw new DataException("An authorized preview sample is required");
        }
        return reader.read(decode(version.getDefinitionJson()), actor, sampleId);
    }

    public Version detail(String id) {
        Actor actor = requireManager();
        Version version = store.find(actor.getTenantId(), id);
        if (version == null) throw new DataException("Source version not found");
        return version;
    }

    @AuditLog(action = "ELN_SOURCE_DRAFT_UPDATE", bizType = "ELN_SOURCE",
            bizCodeExpr = "#result?.propertyCode", bizCodeRequired = false,
            targetTable = "lims_eln_provider_property_version", targetIdExpr = "#id")
    public Version updateDraft(String id, int expectedEditVersion, Draft changes) {
        Version previous = detail(id);
        if (!"DRAFT".equals(previous.getStatus())) throw new DataException("Published source is immutable");
        if (previous.getEditVersion() != expectedEditVersion) throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_CONFLICT", "Source version has changed");
        if (changes == null || !previous.getPropertyCode().equals(changes.getPropertyCode())) {
            throw new DataException("Source property code is immutable");
        }
        validateMetadata(changes);
        Version replacement = new Version(previous.getId(), previous.getTenantId(), previous.getPropertyCode(),
                previous.getRevision(), "DRAFT", changes.getDisplayName(), changes.getDataType(),
                encode(changes.getDefinition()), null, null, null, null, previous.getEditVersion() + 1);
        if (!store.replaceDraft(previous, replacement)) throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_CONFLICT", "Source version has changed");
        return replacement;
    }

    @AuditLog(action = "ELN_SOURCE_VERSION_CREATE", bizType = "ELN_SOURCE",
            bizCodeExpr = "#result?.propertyCode", bizCodeRequired = false,
            targetTable = "lims_eln_provider_property_version", targetIdExpr = "#result?.id")
    public Version newVersion(String publishedId, Draft changes) {
        Version previous = detail(publishedId);
        if (!"PUBLISHED".equals(previous.getStatus())) throw new DataException("Published source required");
        if (changes == null || !previous.getPropertyCode().equals(changes.getPropertyCode())) {
            throw new DataException("Source property code is immutable");
        }
        validateMetadata(changes);
        int revision = 0;
        for (Version version : store.list(previous.getTenantId())) {
            if (!previous.getPropertyCode().equals(version.getPropertyCode())) continue;
            if ("DRAFT".equals(version.getStatus())) throw new DataException("Source already has a draft");
            revision = Math.max(revision, version.getRevision());
        }
        Version draft = new Version(UUID.randomUUID().toString(), previous.getTenantId(),
                previous.getPropertyCode(), revision + 1, "DRAFT", changes.getDisplayName(),
                changes.getDataType(), encode(changes.getDefinition()), null, null, null, null, 0);
        store.insert(draft);
        return draft;
    }

    public ElnSourceReference reference(String code, int revision) {
        Version version = published(code, revision);
        return reference(version);
    }

    public List<ElnSourceReference> references() {
        return catalog().stream().map(version -> reference(version, true)).collect(Collectors.toList());
    }

    private ElnSourceReference reference(Version version) {
        return reference(version, store.enabled(version.getTenantId(), version.getPropertyCode()));
    }

    private ElnSourceReference reference(Version version, boolean enabled) {
        ElnSourceReference result = new ElnSourceReference();
        result.setPropertyCode(version.getPropertyCode());
        result.setRevision(version.getRevision());
        result.setDisplayName(version.getDisplayName());
        result.setDataType(version.getDataType());
        result.setEnabled(enabled);
        return result;
    }

    public Version published(String code, int revision) {
        return published(code, revision, requireActor());
    }

    Version published(String code, int revision, Actor actor) {
        requireActor(actor);
        return store.list(actor.getTenantId()).stream()
                .filter(v -> code.equals(v.getPropertyCode()) && revision == v.getRevision()
                        && "PUBLISHED".equals(v.getStatus())).findFirst()
                .orElseThrow(() -> new LimsElnReadonlyResolver.SourceFailure("UNSUPPORTED_PROPERTY", "Published source version not found"));
    }

    @AuditLog(action = "ELN_SOURCE_SET_ENABLED", bizType = "ELN_SOURCE", bizCodeExpr = "#code",
            targetTable = "lims_eln_provider_property", targetIdExpr = "#code")
    public void setEnabled(String code, boolean enabled) {
        Actor actor = requireManager();
        if (store.list(actor.getTenantId()).stream().noneMatch(v -> code.equals(v.getPropertyCode()))) {
            throw new DataException("Source property not found");
        }
        store.setEnabled(actor.getTenantId(), code, enabled);
    }

    public Definition definition(String id) {
        return decode(detail(id).getDefinitionJson());
    }

    Definition definition(Version version) {
        if (version == null) throw new DataException("Source version is required");
        return decode(version.getDefinitionJson());
    }

    private Definition decode(String definitionJson) {
        try {
            return json.readValue(definitionJson, Definition.class);
        } catch (JsonProcessingException e) {
            throw new DataException("Source definition is invalid");
        }
    }

    public List<Version> catalog() {
        Actor actor = requireManager();
        Map<String, Boolean> enabledStates = store.enabledStates(actor.getTenantId());
        Map<String, Version> current = new LinkedHashMap<>();
        for (Version version : store.list(actor.getTenantId())) {
            if (!"PUBLISHED".equals(version.getStatus())) continue;
            Version previous = current.get(version.getPropertyCode());
            if (previous == null || previous.getRevision() < version.getRevision()) {
                current.put(version.getPropertyCode(), version);
            }
        }
        return current.values().stream()
                .filter(v -> enabledStates.getOrDefault(v.getPropertyCode(), false))
                .collect(Collectors.toList());
    }

    public List<Version> versions() {
        return store.list(requireManager().getTenantId());
    }

    public boolean enabled(String code) {
        return store.enabled(requireManager().getTenantId(), code);
    }

    Map<String, Boolean> enabledStates() {
        return store.enabledStates(requireManager().getTenantId());
    }

    private Actor requireManager() {
        Actor actor = requireActor();
        if (!actor.isFieldManager()) throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_FORBIDDEN", "Field management permission required");
        return actor;
    }

    private Actor requireActor() {
        return requireActor(actors.get());
    }

    static Actor requireActor(Actor actor) {
        if (actor == null || actor.getUserId() == null
                || actor.getUserId().trim().isEmpty()) {
            throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_FORBIDDEN", "Authenticated source caller required");
        }
        if (!"0".equals(actor.getTenantId())) throw new LimsElnReadonlyResolver.SourceFailure("SOURCE_FORBIDDEN", "Invalid tenant context");
        return actor;
    }

    private String encode(Definition definition) {
        if (definition == null) throw new DataException("Source definition is required");
        try {
            return json.writeValueAsString(definition);
        } catch (JsonProcessingException e) {
            throw new DataException("Source definition is invalid");
        }
    }

    private static boolean matchesType(String type, Object value) {
        if ("TEXT".equals(type)) return value instanceof String;
        if ("DECIMAL".equals(type)) {
            return value instanceof java.math.BigDecimal || value instanceof java.math.BigInteger
                    || value instanceof Byte || value instanceof Short || value instanceof Integer || value instanceof Long;
        }
        if ("DATE".equals(type)) return value instanceof java.time.LocalDate || value instanceof java.sql.Date;
        if ("DATETIME".equals(type)) {
            return value instanceof java.time.LocalDateTime || value instanceof java.time.OffsetDateTime
                    || value instanceof Instant || value instanceof java.sql.Timestamp;
        }
        return "BOOLEAN".equals(type) && value instanceof Boolean;
    }

    private static void validateMetadata(Draft draft) {
        if (draft.getDisplayName() == null || draft.getDisplayName().trim().isEmpty()
                || draft.getDisplayName().length() > 200) {
            throw new DataException("Source business name is required and must not exceed 200 characters");
        }
        if (!java.util.Arrays.asList("TEXT", "DECIMAL", "DATE", "DATETIME", "BOOLEAN").contains(draft.getDataType())) {
            throw new DataException("Unsupported source scalar type");
        }
    }

    public interface Store {
        void insert(Version version);
        Version find(String tenantId, String id);
        List<Version> list(String tenantId);
        boolean replaceDraft(Version expected, Version replacement);
        boolean enabled(String tenantId, String code);
        Map<String, Boolean> enabledStates(String tenantId);
        void setEnabled(String tenantId, String code, boolean enabled);
    }

    /**
     * Trusted business-data adapter: validate controlled metadata, authorize the sample and enforce
     * single-valued relationships. Return the complete executable snapshot, never a client preview token.
     */
    public interface SourceReader {
        Preview read(Definition definition, Actor actor, String sampleId);
    }

    @Value
    public static class Preview {
        List<?> values;
        String frozenDefinitionJson;
    }

    /** Server-derived context, not a request body. */
    @Value
    public static class Actor {
        String tenantId;
        String userId;
        boolean fieldManager;
    }

    @Value
    public static class Draft {
        String propertyCode;
        String displayName;
        String dataType;
        Definition definition;
    }

    @Data
    @com.fasterxml.jackson.databind.annotation.JsonNaming(com.fasterxml.jackson.databind.PropertyNamingStrategies.LowerCamelCaseStrategy.class)
    public static class Definition {
        private String objectId;
        private String fieldId;
        private String datasetCode;
        private Integer datasetRevision;
    }

    @Value
    @com.fasterxml.jackson.databind.annotation.JsonNaming(com.fasterxml.jackson.databind.PropertyNamingStrategies.LowerCamelCaseStrategy.class)
    public static class Version {
        String id;
        String tenantId;
        String propertyCode;
        int revision;
        String status;
        String displayName;
        String dataType;
        String definitionJson;
        @com.fasterxml.jackson.annotation.JsonIgnore
        String frozenDefinitionJson;
        String validationSampleId;
        String publishedBy;
        String publishedAt;
        int editVersion;
    }
}