/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gudusoft.gsqlparser.sqlenv.calcite;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ext.calcite.sqlnamematcher.SqlNameMatcher;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

import java.util.*;

/**
 * Centralized name matching service using Apache Calcite's SqlNameMatcher framework.
 *
 * <p>This service provides vendor-aware and type-aware name comparison utilities,
 * replacing scattered string comparisons throughout GSP with a unified approach.</p>
 *
 * <p>Key responsibilities:</p>
 * <ul>
 *   <li>Name equality checking (case-sensitive or insensitive per vendor/type)</li>
 *   <li>Case-aware collection operations (indexOf, distinct, Set creation)</li>
 *   <li>Bridge between GSP's normalization rules and Calcite's matching framework</li>
 * </ul>
 *
 * <p>Design: This service delegates to {@link NamePolicyFactory} for matcher instances
 * and preserves {@link TSQLEnv#normalizeIdentifier} as the authority for identifier
 * quoting and default-case normalization.</p>
 *
 * @since 3.2.0.3 (Phase 1)
 */
public class NameService {

    private final EDbVendor vendor;
    private final NamePolicyFactory factory;

    /**
     * Creates a new NameService for the specified database vendor.
     *
     * @param vendor the database vendor
     */
    public NameService(EDbVendor vendor) {
        if (vendor == null) {
            throw new IllegalArgumentException("vendor cannot be null");
        }
        this.vendor = vendor;
        this.factory = new NamePolicyFactory(vendor);
    }

    /**
     * Returns the database vendor associated with this service.
     *
     * @return the database vendor
     */
    public EDbVendor getVendor() {
        return vendor;
    }

    /**
     * Checks if two names are equal according to vendor-specific and type-specific rules.
     *
     * <p>This method replaces {@code TSQLEnv.compareIdentifier()} with a more robust
     * implementation backed by Calcite's SqlNameMatcher framework.</p>
     *
     * <p>Names are normalized using GSP's existing rules before matching.</p>
     *
     * @param type the SQL object type (table, column, function, etc.)
     * @param name1 the first name to compare
     * @param name2 the second name to compare
     * @return true if the names match according to vendor/type rules
     */
    public boolean equals(ESQLDataObjectType type, String name1, String name2) {
        if (name1 == null || name2 == null) {
            return name1 == name2;
        }

        // Normalize identifiers using GSP's existing quoting/case rules
        String normalized1 = IdentifierService.normalizeStatic(vendor, type, name1);
        String normalized2 = IdentifierService.normalizeStatic(vendor, type, name2);

        // Use Calcite matcher for case-aware comparison
        SqlNameMatcher matcher = factory.getMatcherForType(type);
        return matcher.matches(normalized1, normalized2);
    }

    /**
     * Finds the index of a name in a collection, using vendor/type-aware matching.
     *
     * <p>This is a case-aware version of {@code List.indexOf()}.</p>
     *
     * @param type the SQL object type
     * @param names the collection of names to search
     * @param target the name to find
     * @return the index of the first matching name, or -1 if not found
     */
    public int indexOf(ESQLDataObjectType type, Iterable<String> names, String target) {
        if (names == null || target == null) {
            return -1;
        }

        int index = 0;
        for (String name : names) {
            if (equals(type, name, target)) {
                return index;
            }
            index++;
        }
        return -1;
    }

    /**
     * Creates a distinct copy of a collection, removing duplicates using vendor/type-aware matching.
     *
     * <p>Preserves insertion order. For example, with case-insensitive matching:</p>
     * <pre>
     * ["foo", "FOO", "bar", "Bar"] → ["foo", "bar"]
     * </pre>
     *
     * @param type the SQL object type
     * @param names the collection of names (may contain duplicates)
     * @return a new list with duplicates removed, preserving order
     */
    public List<String> distinctCopy(ESQLDataObjectType type, Iterable<String> names) {
        if (names == null) {
            return new ArrayList<>();
        }

        Set<String> seen = createSet(type);
        List<String> result = new ArrayList<>();

        for (String name : names) {
            if (name != null) {
                String normalized = IdentifierService.normalizeStatic(vendor, type, name);
                if (seen.add(normalized)) {
                    result.add(name); // Keep original name, not normalized
                }
            }
        }

        return result;
    }

    /**
     * Creates a Set that uses vendor/type-aware name matching for equality.
     *
     * <p>The returned Set will treat names as equal if they match according to
     * the vendor's case sensitivity rules for the specified object type.</p>
     *
     * <p>Implementation note: Uses a wrapper around LinkedHashSet that normalizes
     * keys before insertion/lookup.</p>
     *
     * @param type the SQL object type
     * @return a new Set with case-aware equality
     */
    public Set<String> createSet(ESQLDataObjectType type) {
        return new NameSet(type);
    }

    /**
     * Checks if a specific object type is case-sensitive for this vendor.
     *
     * <p>Convenience method that delegates to {@link NamePolicyFactory}.</p>
     *
     * @param type the object type
     * @return true if case-sensitive, false otherwise
     */
    public boolean isCaseSensitive(ESQLDataObjectType type) {
        return factory.isCaseSensitive(type);
    }

    /**
     * Internal Set implementation that uses vendor/type-aware name matching.
     *
     * <p>This wrapper normalizes all keys before delegating to a standard LinkedHashSet,
     * ensuring that name matching follows vendor-specific case sensitivity rules.</p>
     */
    private class NameSet extends AbstractSet<String> {
        private final ESQLDataObjectType type;
        private final Map<String, String> backingMap; // normalized -> original

        NameSet(ESQLDataObjectType type) {
            this.type = type;
            this.backingMap = new LinkedHashMap<>();
        }

        @Override
        public boolean add(String name) {
            if (name == null) {
                throw new NullPointerException("NameSet does not permit null elements");
            }
            String normalized = IdentifierService.normalizeStatic(vendor, type, name);
            return backingMap.putIfAbsent(normalized, name) == null;
        }

        @Override
        public boolean contains(Object o) {
            if (!(o instanceof String)) {
                return false;
            }
            String normalized = IdentifierService.normalizeStatic(vendor, type, (String) o);
            return backingMap.containsKey(normalized);
        }

        @Override
        public boolean remove(Object o) {
            if (!(o instanceof String)) {
                return false;
            }
            String normalized = IdentifierService.normalizeStatic(vendor, type, (String) o);
            return backingMap.remove(normalized) != null;
        }

        @Override
        public Iterator<String> iterator() {
            return backingMap.values().iterator();
        }

        @Override
        public int size() {
            return backingMap.size();
        }

        @Override
        public void clear() {
            backingMap.clear();
        }
    }
}