package com.battery.device.neware;

import java.io.PrintWriter;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.Statement;
import java.util.List;
import java.util.Locale;
import java.util.logging.Logger;
import javax.sql.DataSource;

/**
 * 厂商数据源的只读防线：在 JDBC 调用到达驱动之前按语句白名单放行。
 *
 * <p>只允许 {@code SELECT} / {@code SHOW} / {@code DESCRIBE}（含 {@code DESC}）；
 * 其余语句（含存储过程调用）直接抛 {@link NonQueryStatementException}，不转发给驱动，
 * 因此在服务端不产生任何效果。被拒绝的语句记入 {@link ReadOnlyStatementAudit}，
 * 使"该数据源从未发出过非查询语句"可以被测试断言。
 *
 * <p>防线是结构性的，不是数学上的：任何绕过本数据源另开连接的代码仍能写。
 * 服务端只读账号（见现场对接清单第七节）是第一道防线，本层是第二道。
 *
 * <p>{@link DataSource} 接口中与只读边界无关的 JDK 样板方法（日志写出器、登录超时、
 * 父日志器、{@code unwrap} / {@code isWrapperFor} / {@code toString}）直接转发或拒绝驱动对象，
 * 不承载业务语义，因此不单独加方法注释。
 */
public final class ReadOnlyVendorDataSource implements DataSource
{
    private static final List<String> ALLOWED_PREFIXES = List.of("select", "show", "describe", "desc");
    /**
     * 加锁读会真的阻塞厂商写入，所以它虽然以 {@code select} 开头也要单独拒绝：
     * 现场实测厂商库 {@code tx_isolation=REPEATABLE-READ}，行锁会挡住上位机的写库。
     */
    private static final List<String> LOCKING_CLAUSES = List.of("for update", "for share",
            "lock in share mode", "updlock", "holdlock", "xlock", "tablock");

    private final DataSource delegate;
    private final String sourceLabel;
    private final ReadOnlyStatementAudit audit = new ReadOnlyStatementAudit();

    public ReadOnlyVendorDataSource(DataSource delegate, String sourceLabel)
    {
        if (delegate == null) throw new IllegalArgumentException("delegate data source must not be null");
        this.delegate = delegate;
        this.sourceLabel = sourceLabel == null || sourceLabel.isBlank() ? "vendor" : sourceLabel.trim();
    }

    /** 返回本数据源上的语句审计，用于断言从未发出过非查询语句。 */
    public ReadOnlyStatementAudit audit()
    {
        return audit;
    }

    /** 取一条受只读约束的连接；语句白名单在返回的连接代理上生效。 */
    @Override
    public Connection getConnection() throws SQLException
    {
        return guard(delegate.getConnection());
    }

    /** 同上，按给定账号取连接；账号仍受只读白名单约束。 */
    @Override
    public Connection getConnection(String username, String password) throws SQLException
    {
        return guard(delegate.getConnection(username, password));
    }

    private Connection guard(Connection connection)
    {
        return (Connection) Proxy.newProxyInstance(connection.getClass().getClassLoader(),
                new Class<?>[] { Connection.class }, (proxy, method, args) -> {
                    switch (method.getName())
                    {
                        case "prepareStatement" ->
                        {
                            String sql = (String) args[0];
                            requireQuery(sql);
                            return guardStatement((Statement) invoke(connection, method, args), sql, true);
                        }
                        case "prepareCall" -> throw new NonQueryStatementException(
                                "厂商数据源禁止存储过程调用：" + abbreviate((String) args[0]));
                        case "createStatement" ->
                        {
                            return guardStatement((Statement) invoke(connection, method, args), null, false);
                        }
                        default -> { }
                    }
                    return invoke(connection, method, args);
                });
    }

    private Statement guardStatement(Statement statement, String preparedSql, boolean prepared)
    {
        Class<?> statementType = prepared ? PreparedStatement.class : Statement.class;
        return (Statement) Proxy.newProxyInstance(statement.getClass().getClassLoader(),
                new Class<?>[] { statementType }, (proxy, method, args) -> {
                    String sql = sqlArgument(method, args);
                    if (sql != null) requireQuery(sql);
                    return invoke(statement, method, args);
                });
    }

    /**
     * 取出本次调用携带的 SQL 文本：语句级方法带 SQL 时按该 SQL 判定，
     * 预编译语句的无参执行按 prepare 时的 SQL 判定（已在 prepareStatement 中放行）。
     */
    private static String sqlArgument(Method method, Object[] args)
    {
        if (args == null || args.length == 0 || !(args[0] instanceof String sql)) return null;
        return switch (method.getName())
        {
            case "execute", "executeUpdate", "executeLargeUpdate", "executeQuery", "addBatch", "executeBatch",
                    "executeLargeBatch" -> sql;
            default -> null;
        };
    }

    private void requireQuery(String sql)
    {
        boolean query = isQuery(sql);
        boolean locking = query && containsLockingClause(sql);
        if (query && !locking)
        {
            audit.recordForwarded(sql);
            return;
        }
        audit.recordRejected(sql);
        throw new NonQueryStatementException(locking
                ? "厂商数据源禁止加锁读（会阻塞厂商写入）：" + abbreviate(sql)
                : "厂商数据源只允许查询语句：" + abbreviate(sql));
    }

    /** 只按语句首关键字判定，避免用正则近似 SQL 语法。 */
    static boolean isQuery(String sql)
    {
        if (sql == null) return false;
        String normalized = stripLeadingComments(sql).toLowerCase(Locale.ROOT);
        if (normalized.isEmpty()) return false;
        for (String prefix : ALLOWED_PREFIXES)
        {
            if (!normalized.startsWith(prefix)) continue;
            int boundary = prefix.length();
            if (normalized.length() == boundary || Character.isWhitespace(normalized.charAt(boundary))
                    || normalized.charAt(boundary) == '(' || normalized.charAt(boundary) == '*'
                    || normalized.charAt(boundary) == '`')
                return true;
        }
        return false;
    }

    /**
     * 语句里是否带加锁读子句。这是**语法层的拦截**，不是 SQL 解析器：厂商取数的语句由本模块固定给出，
     * 不会把加锁子句藏在字符串常量里；新增取数语句时由 {@code ReadOnlyVendorDataSourceTest} 一起覆盖。
     */
    static boolean containsLockingClause(String sql)
    {
        if (sql == null) return false;
        String normalized = stripLeadingComments(sql).toLowerCase(Locale.ROOT).replaceAll("\\s+", " ");
        for (String clause : LOCKING_CLAUSES)
        {
            if (normalized.contains(clause)) return true;
        }
        return false;
    }

    private static String stripLeadingComments(String sql)
    {
        String remaining = sql.trim();
        while (true)
        {
            if (remaining.startsWith("/*"))
            {
                int end = remaining.indexOf("*/");
                if (end < 0) return remaining;
                remaining = remaining.substring(end + 2).trim();
                continue;
            }
            if (remaining.startsWith("--") || remaining.startsWith("#"))
            {
                int end = remaining.indexOf('\n');
                if (end < 0) return "";
                remaining = remaining.substring(end + 1).trim();
                continue;
            }
            return remaining;
        }
    }

    private static String abbreviate(String sql)
    {
        if (sql == null) return "";
        String trimmed = sql.trim();
        return trimmed.length() <= 200 ? trimmed : trimmed.substring(0, 200);
    }

    private static Object invoke(Object target, Method method, Object[] args) throws Throwable
    {
        try
        {
            return method.invoke(target, args);
        }
        catch (InvocationTargetException exception)
        {
            throw exception.getTargetException();
        }
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException
    {
        return delegate.getLogWriter();
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException
    {
        delegate.setLogWriter(out);
    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException
    {
        delegate.setLoginTimeout(seconds);
    }

    @Override
    public int getLoginTimeout() throws SQLException
    {
        return delegate.getLoginTimeout();
    }

    @Override
    public Logger getParentLogger() throws SQLFeatureNotSupportedException
    {
        return delegate.getParentLogger();
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException
    {
        if (iface.isInstance(this)) return iface.cast(this);
        throw new SQLFeatureNotSupportedException("厂商数据源不暴露未受约束的驱动对象");
    }

    @Override
    public boolean isWrapperFor(Class<?> iface)
    {
        return iface.isInstance(this);
    }

    @Override
    public String toString()
    {
        return "ReadOnlyVendorDataSource[" + sourceLabel + "]";
    }

    /** 便于测试与排查的来源说明。 */
    public String sourceLabel()
    {
        return sourceLabel;
    }
}