package gudusoft.gsqlparser.catalog.runtime;

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

/**
 * Factory + immutable record for {@link CatalogEntry}.
 *
 * <p>Plan §7.2. Held separately from the interface so consumers (resolver, bridge mapper)
 * can construct entries without touching the snapshot internals.</p>
 *
 * <p>{@link #builder()} returns a builder; {@link #of} is the convenience static for the
 * common case (no children, no extra properties).</p>
 */
public final class CatalogEntries {

    private CatalogEntries() {
        // Static factory.
    }

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

    public static CatalogEntry of(CatalogObjectId id,
                                  CatalogQualifiedName name,
                                  CatalogObjectKind kind) {
        return builder().id(id).name(name).kind(kind).build();
    }

    public static CatalogEntry of(CatalogObjectId id,
                                  CatalogQualifiedName name,
                                  CatalogObjectKind kind,
                                  Map<String, Object> properties) {
        Builder b = builder().id(id).name(name).kind(kind);
        if (properties != null) {
            for (Map.Entry<String, Object> e : properties.entrySet()) {
                b.property(e.getKey(), e.getValue());
            }
        }
        return b.build();
    }

    /** Compute a stable {@link CatalogObjectId} from a qualified name. */
    public static CatalogObjectId derivedIdFor(CatalogQualifiedName name) {
        if (name == null) {
            throw new IllegalArgumentException("CatalogEntries.derivedIdFor: name is required");
        }
        return CatalogObjectId.of(CatalogIdentifierPolicy.keyForMap(name));
    }

    public static final class Builder {

        private CatalogObjectId id;
        private CatalogQualifiedName name;
        private CatalogObjectKind kind;
        private final Map<String, Object> properties = new LinkedHashMap<String, Object>();
        private final List<CatalogObjectId> childIds = new ArrayList<CatalogObjectId>();

        private Builder() {
        }

        public Builder id(CatalogObjectId v) {
            this.id = v;
            return this;
        }

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

        public Builder kind(CatalogObjectKind v) {
            this.kind = v;
            return this;
        }

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

        /**
         * Pre-record the {@link CatalogObjectId} of a direct child. Used so that the
         * snapshot's {@code children(parent, kind)} call can return a structured list
         * without walking every entry.
         */
        public Builder addChild(CatalogObjectId childId) {
            if (childId == null) {
                throw new IllegalArgumentException("CatalogEntry child id may not be null");
            }
            this.childIds.add(childId);
            return this;
        }

        public CatalogEntry build() {
            if (id == null) {
                throw new IllegalArgumentException("CatalogEntry.id is required");
            }
            if (name == null) {
                throw new IllegalArgumentException("CatalogEntry.name is required");
            }
            if (kind == null) {
                throw new IllegalArgumentException("CatalogEntry.kind is required");
            }
            return new ImmutableCatalogEntry(id, name, kind, properties, childIds);
        }
    }

    static final class ImmutableCatalogEntry implements CatalogEntry {

        private final CatalogObjectId id;
        private final CatalogQualifiedName name;
        private final CatalogObjectKind kind;
        private final Map<String, Object> properties;
        private final List<CatalogObjectId> childIds;

        ImmutableCatalogEntry(CatalogObjectId id,
                              CatalogQualifiedName name,
                              CatalogObjectKind kind,
                              Map<String, Object> properties,
                              List<CatalogObjectId> childIds) {
            this.id = id;
            this.name = name;
            this.kind = kind;
            this.properties = Collections.unmodifiableMap(new LinkedHashMap<String, Object>(properties));
            this.childIds = Collections.unmodifiableList(new ArrayList<CatalogObjectId>(childIds));
        }

        @Override
        public CatalogObjectId id() {
            return id;
        }

        @Override
        public CatalogQualifiedName name() {
            return name;
        }

        @Override
        public CatalogObjectKind kind() {
            return kind;
        }

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

        /** Internal accessor used by {@link InMemoryCatalogSnapshot#children}. */
        List<CatalogObjectId> childIds() {
            return childIds;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof ImmutableCatalogEntry)) return false;
            ImmutableCatalogEntry that = (ImmutableCatalogEntry) o;
            return id.equals(that.id)
                && name.equals(that.name)
                && kind == that.kind
                && properties.equals(that.properties)
                && childIds.equals(that.childIds);
        }

        @Override
        public int hashCode() {
            return Objects.hash(id, name, kind, properties, childIds);
        }

        @Override
        public String toString() {
            return "CatalogEntry{id=" + id + ", name=" + name + ", kind=" + kind + '}';
        }
    }
}