package gudusoft.gsqlparser.catalog.input.model;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * Table entry inside a {@link SchemaModel}.
 *
 * <p>Plan §6. {@link #properties()} is the vendor-extension escape hatch
 * (per plan R6 / Q15) that carries adapter-specific metadata (Hive table
 * properties, Iceberg snapshot id, OpenMetadata tags, etc.) until a field
 * earns promotion to a typed accessor.</p>
 *
 * <p>Property values held in the map are frozen on build at one level of
 * depth: {@link List} values are wrapped via {@link Collections#unmodifiableList},
 * {@link Map} values via {@link Collections#unmodifiableMap}. Adapters that
 * stash deeper nested mutable structures (e.g. a {@code List<Map<...>>} whose
 * inner maps remain mutable) are still expected to supply value objects that
 * are themselves immutable; the model does not deep-copy.</p>
 */
public final class TableModel {

    private final String name;
    private final List<ColumnModel> columns;
    private final List<ConstraintModel> constraints;
    private final List<IndexModel> indexes;
    private final Map<String, Object> properties;

    private TableModel(Builder b) {
        if (b.name == null || b.name.isEmpty()) {
            throw new IllegalArgumentException("TableModel.name is required");
        }
        this.name = b.name;
        this.columns = Collections.unmodifiableList(new ArrayList<ColumnModel>(b.columns));
        this.constraints = Collections.unmodifiableList(new ArrayList<ConstraintModel>(b.constraints));
        this.indexes = Collections.unmodifiableList(new ArrayList<IndexModel>(b.indexes));
        // LinkedHashMap to preserve insertion order for deterministic toString / golden output.
        // Freeze List / Map values on the way in so a caller mutating their original
        // reference cannot disturb the model's equals/hashCode contract.
        LinkedHashMap<String, Object> frozen = new LinkedHashMap<String, Object>(b.properties.size());
        for (Map.Entry<String, Object> e : b.properties.entrySet()) {
            frozen.put(e.getKey(), freezePropertyValue(e.getValue()));
        }
        this.properties = Collections.unmodifiableMap(frozen);
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    private static Object freezePropertyValue(Object value) {
        if (value instanceof List) {
            return Collections.unmodifiableList(new ArrayList((List) value));
        }
        if (value instanceof Map) {
            return Collections.unmodifiableMap(new LinkedHashMap((Map) value));
        }
        return value;
    }

    public static Builder builder() {
        return new Builder();
    }

    public String name() {
        return name;
    }

    public List<ColumnModel> columns() {
        return columns;
    }

    public List<ConstraintModel> constraints() {
        return constraints;
    }

    public List<IndexModel> indexes() {
        return indexes;
    }

    public Map<String, Object> properties() {
        return properties;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof TableModel)) return false;
        TableModel that = (TableModel) o;
        return name.equals(that.name)
            && columns.equals(that.columns)
            && constraints.equals(that.constraints)
            && indexes.equals(that.indexes)
            && properties.equals(that.properties);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, columns, constraints, indexes, properties);
    }

    @Override
    public String toString() {
        return "TableModel{name=" + name
            + ", cols=" + columns.size()
            + ", constraints=" + constraints.size()
            + ", indexes=" + indexes.size()
            + ", props=" + properties.size() + '}';
    }

    public static final class Builder {

        private String name;
        private final List<ColumnModel> columns = new ArrayList<ColumnModel>();
        private final List<ConstraintModel> constraints = new ArrayList<ConstraintModel>();
        private final List<IndexModel> indexes = new ArrayList<IndexModel>();
        private final Map<String, Object> properties = new LinkedHashMap<String, Object>();

        private Builder() {
        }

        public Builder name(String v) {
            this.name = v;
            return this;
        }

        public Builder addColumn(ColumnModel v) {
            if (v == null) {
                throw new IllegalArgumentException("TableModel column may not be null");
            }
            this.columns.add(v);
            return this;
        }

        public Builder addConstraint(ConstraintModel v) {
            if (v == null) {
                throw new IllegalArgumentException("TableModel constraint may not be null");
            }
            this.constraints.add(v);
            return this;
        }

        public Builder addIndex(IndexModel v) {
            if (v == null) {
                throw new IllegalArgumentException("TableModel index may not be null");
            }
            this.indexes.add(v);
            return this;
        }

        public Builder property(String key, Object value) {
            if (key == null) {
                throw new IllegalArgumentException("TableModel property key may not be null");
            }
            this.properties.put(key, value);
            return this;
        }

        public TableModel build() {
            return new TableModel(this);
        }
    }
}