package org.openautonomousconnection.insserver;

import org.openautonomousconnection.protocol.side.ins.ProtocolINSServer;
import org.openautonomousconnection.protocol.versions.v1_0_0.beta.INSRecord;
import org.openautonomousconnection.protocol.versions.v1_0_0.beta.INSRecordType;

import java.io.IOException;
import java.security.cert.CertificateException;
import java.sql.*;
import java.util.*;

/**
 * Database-backed INS server.
 * <p>
 * This implementation resolves records from the SQL schema and performs CNAME recursion (with loop detection + depth limit).
 * Returned records are deterministically sorted so that callers can safely select index 0 as the "best" record.
 */
public final class DatabaseINSServer extends ProtocolINSServer {

    private final String jdbcUrl;
    private final String jdbcUser;
    private final String jdbcPassword;

    /**
     * Creates a new database-backed INS server.
     *
     * @throws IOException          If the base server initialization fails.
     * @throws CertificateException If required certificate files are missing or invalid.
     */
    public DatabaseINSServer(String insInfoSite, String insFrontendSite, String jdbcUrl, String jdbcUser, String jdbcPassword) throws Exception {
        super(insInfoSite, insFrontendSite);

        this.jdbcUrl = jdbcUrl;
        this.jdbcUser = jdbcUser;
        this.jdbcPassword = jdbcPassword;
    }

    private static int safeInt(int v) {
        return v;
    }

    private static String safeString(String s) {
        return s == null ? "" : s;
    }

    private Connection openConnection() throws SQLException {
        return DriverManager.getConnection(jdbcUrl, jdbcUser, jdbcPassword);
    }

    /**
     * Resolves a request for an INS record based on TLN, name, subname and record type.
     * <p>
     * The implementation:
     * <ul>
     *     <li>Locates the corresponding InfoName in the SQL schema</li>
     *     <li>Returns all matching {@link INSRecord} entries</li>
     *     <li>Performs CNAME recursion (with loop detection + depth limit) when no direct records for the requested type exist</li>
     *     <li>Returns deterministically sorted results (so index 0 can be used as "best record")</li>
     * </ul>
     *
     * @param tln  The top-level name.
     * @param name The InfoName.
     * @param sub  Optional subname, may be {@code null}.
     * @param type The requested record type.
     * @return Resolved records (possibly empty).
     */
    @Override
    public List<INSRecord> resolve(String tln, String name, String sub, INSRecordType type) {
        try {
            List<INSRecord> out = resolveInternal(tln, name, sub, type, 0, new HashSet<>());
            out.sort(recordComparator(type));
            return out;
        } catch (SQLException ex) {
            getProtocolBridge().getLogger().exception(
                    "INS resolve failed for " + formatName(tln, name, sub) + " type=" + type,
                    ex
            );
            return new ArrayList<>();
        }
    }

    /**
     * Resolves the TLN info site which is used when a client queries {@code info.<tln>} without any sub-name.
     * <p>
     * The value is read from {@code tln.info} and must be of the form {@code "host:port"}.
     *
     * @param tln The TLN name.
     * @return The configured info target ("host:port") or {@code null} if not present.
     */
    @Override
    public String resolveTLNInfoSite(String tln) {
        String sql = "SELECT info FROM tln WHERE name = ?";

        try (Connection conn = openConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {

            ps.setString(1, tln);

            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) return rs.getString("info");
            }
        } catch (SQLException ex) {
            getProtocolBridge().getLogger().exception("Failed to resolve TLN info site for tln=" + tln, ex);
        }

        return null;
    }

    private String formatName(String tln, String name, String sub) {
        if (sub == null || sub.isEmpty()) return name + "." + tln;
        return sub + "." + name + "." + tln;
    }

    /**
     * Internal recursive resolver with CNAME handling.
     *
     * @param depth   Current recursion depth.
     * @param visited Loop detection set of canonical names (sub.name.tln).
     */
    private List<INSRecord> resolveInternal(
            String tln,
            String name,
            String sub,
            INSRecordType requestedType,
            int depth,
            Set<String> visited
    ) throws SQLException {

        final int MAX_CNAME_DEPTH = 16;

        String canonical = formatName(tln, name, sub).toLowerCase(Locale.ROOT);
        if (!visited.add(canonical)) {
            // loop detected
            getProtocolBridge().getLogger().warn("CNAME loop detected for " + canonical + " type=" + requestedType);
            return new ArrayList<>();
        }

        if (depth > MAX_CNAME_DEPTH) {
            getProtocolBridge().getLogger().warn("CNAME recursion limit exceeded for " + canonical + " type=" + requestedType);
            return new ArrayList<>();
        }

        try (Connection conn = openConnection()) {
            Integer tlnId = findTLNId(conn, tln);
            if (tlnId == null) return new ArrayList<>();

            Integer infoNameId = findInfoNameId(conn, tlnId, name);
            if (infoNameId == null) return new ArrayList<>();

            Integer subNameId = findSubNameId(conn, infoNameId, sub);

            // 1) direct records
            List<INSRecord> direct = loadRecords(conn, infoNameId, subNameId, requestedType);
            direct.sort(recordComparator(requestedType));

            // If the requested type is CNAME, do not recurse.
            if (requestedType == INSRecordType.CNAME) return direct;

            if (!direct.isEmpty()) return direct;

            // 2) fallback to CNAME if no direct records exist
            List<INSRecord> cnames = loadRecords(conn, infoNameId, subNameId, INSRecordType.CNAME);
            cnames.sort(recordComparator(INSRecordType.CNAME));

            if (cnames.isEmpty()) return new ArrayList<>();

            List<INSRecord> aggregated = new ArrayList<>();

            for (INSRecord cname : cnames) {
                TargetName target = parseCnameTarget(cname.value);
                if (target == null) {
                    getProtocolBridge().getLogger().warn("Invalid CNAME target '" + cname.value + "' on " + canonical);
                    continue;
                }

                // recurse on the target name to fetch the original requested type
                List<INSRecord> resolvedTarget = resolveInternal(
                        target.tln,
                        target.name,
                        target.sub,
                        requestedType,
                        depth + 1,
                        visited
                );
                aggregated.addAll(resolvedTarget);
            }

            aggregated.sort(recordComparator(requestedType));
            return aggregated;
        } finally {
            // important: visited is shared across the recursion chain on purpose
            // (do not remove canonical here; loop detection should stay for the whole chain)
        }
    }

    /**
     * Deterministic ordering for returned records. The goal is stable ranking so callers can pick index 0.
     *
     * <p>Rules:
     * <ul>
     *     <li>priority ASC (smaller is better)</li>
     *     <li>weight DESC (larger is better)</li>
     *     <li>port ASC (smaller is better)</li>
     *     <li>ttl DESC (larger is better)</li>
     *     <li>value ASC (case-insensitive) as final tie-breaker</li>
     * </ul>
     *
     * @param requestedType The type being requested (kept for future type-specific tuning).
     * @return Comparator for {@link INSRecord}.
     */
    private Comparator<INSRecord> recordComparator(INSRecordType requestedType) {
        return Comparator
                .comparingInt((INSRecord r) -> safeInt(r.priority))
                .thenComparingInt(r -> -safeInt(r.weight))
                .thenComparingInt(r -> safeInt(r.port))
                .thenComparingInt(r -> -safeInt(r.ttl))
                .thenComparing(r -> safeString(r.value), String.CASE_INSENSITIVE_ORDER);
    }

    /**
     * Loads all records of a given type for (infoname_id, subname_id).
     *
     * @param type May be {@code null} to load all types.
     */
    private List<INSRecord> loadRecords(Connection conn, int infonameId, Integer subnameId, INSRecordType type) throws SQLException {
        StringBuilder sql = new StringBuilder(
                "SELECT type, value, ttl, priority, port, weight " +
                        "FROM records " +
                        "WHERE infoname_id = ? "
        );

        if (subnameId == null) sql.append("AND subname_id IS NULL ");
        else sql.append("AND subname_id = ? ");

        if (type != null) sql.append("AND type = ? ");

        try (PreparedStatement ps = conn.prepareStatement(sql.toString())) {
            int idx = 1;
            ps.setInt(idx++, infonameId);

            if (subnameId != null) ps.setInt(idx++, subnameId);

            if (type != null) ps.setString(idx, type.name());

            List<INSRecord> result = new ArrayList<>();

            try (ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    INSRecordType rType = INSRecordType.valueOf(rs.getString("type"));
                    String value = rs.getString("value");
                    int ttl = rs.getInt("ttl");
                    int priority = rs.getInt("priority");
                    int port = rs.getInt("port");
                    int weight = rs.getInt("weight");

                    result.add(new INSRecord(rType, value, priority, weight, port, ttl));
                }
            }

            return result;
        }
    }

    private Integer findTLNId(Connection conn, String tln) throws SQLException {
        String sql = "SELECT id FROM tln WHERE name = ?";

        try (PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setString(1, tln);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) return rs.getInt("id");
            }
        }
        return null;
    }

    private Integer findInfoNameId(Connection conn, int tlnId, String infoName) throws SQLException {
        String sql = "SELECT id FROM infonames WHERE tln_id = ? AND info = ?";

        try (PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setInt(1, tlnId);
            ps.setString(2, infoName);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) return rs.getInt("id");
            }
        }
        return null;
    }

    private Integer findSubNameId(Connection conn, int infoNameId, String sub) throws SQLException {
        if (sub == null || sub.isEmpty()) return null;

        String sql = "SELECT id FROM subnames WHERE infoname_id = ? AND name = ?";

        try (PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setInt(1, infoNameId);
            ps.setString(2, sub);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) return rs.getInt("id");
            }
        }
        return null;
    }

    /**
     * Parses a CNAME target string into TLN, InfoName and optional subname.
     *
     * @param value Raw CNAME value (e.g. "sub.app.example" or "example.net").
     * @return Parsed {@link TargetName} or {@code null} if invalid.
     */
    private TargetName parseCnameTarget(String value) {
        if (value == null) return null;
        String trimmed = value.trim();
        if (trimmed.isEmpty()) return null;

        String[] parts = trimmed.split("\\.");
        if (parts.length < 2) return null;

        String tln = parts[parts.length - 1];
        String name = parts[parts.length - 2];
        String sub = null;

        if (parts.length > 2) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < parts.length - 2; i++) {
                if (i > 0) sb.append('.');
                sb.append(parts[i]);
            }
            sub = sb.toString();
        }

        return new TargetName(tln, name, sub);
    }

    private static final class TargetName {
        final String tln;
        final String name;
        final String sub;

        TargetName(String tln, String name, String sub) {
            this.tln = tln;
            this.name = name;
            this.sub = sub;
        }
    }

}