package com.battery.device.neware;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;

/**
 * 可控的假厂商库：按新威 7.6 实测表结构（{@code channel} / {@code test} / {@code data_*}）回答适配器的查询，
 * 并把每一条到达"驱动"的语句原样记录下来。
 *
 * <p>它只回答适配器实际使用的查询形态，因此测试断言的是外部行为（发现清单、最新测试、分表定位、
 * 单位换算、水位过滤），不是 SQL 文本本身；记录下来的语句用于断言只读防线没有漏过非查询语句。
 */
final class FakeVendorDatabase
{
    record ChannelRow(long devUid, int unitId, int chlId) { }

    record TestRow(long devUid, int unitId, int chlId, long testId, String startTime,
            String firstTable, String secondTable) { }

    record SampleRow(String table, long testId, int unitId, int chlId, long seqId, int cycle, int stepId,
            String stepType, long testTimeMillis, int voltage, int current, int capacityCharge, int energyCharge,
            int capacityDischarge, int energyDischarge, String testAtime) { }

    /** 工步层一行：工步层不随采样分表滚动，所以没有表名。 */
    record CapStepRow(long testId, long devUid, int unitId, int chlId, long seqId, int cycle, int stepId,
            String stepType, long testTimeMillis, int voltage, int current, int capacityCharge, int energyCharge,
            int capacityDischarge, int energyDischarge, int middleVoltage, String testAtime) { }

    private final List<String> statements = new java.util.concurrent.CopyOnWriteArrayList<>();
    private final List<ChannelRow> channels = new ArrayList<>();
    private final List<TestRow> tests = new ArrayList<>();
    private final List<SampleRow> samples = new ArrayList<>();
    private final List<CapStepRow> capSteps = new ArrayList<>();

    FakeVendorDatabase registeredChannel(long devUid, int unitId, int chlId)
    {
        channels.add(new ChannelRow(devUid, unitId, chlId));
        return this;
    }

    FakeVendorDatabase test(TestRow row)
    {
        tests.add(row);
        return this;
    }

    FakeVendorDatabase sample(SampleRow row)
    {
        samples.add(row);
        return this;
    }

    FakeVendorDatabase capStep(CapStepRow row)
    {
        capSteps.add(row);
        return this;
    }

    /** 到达"驱动"的语句原文，按调用顺序。 */
    List<String> statements()
    {
        return List.copyOf(statements);
    }

    DataSource dataSource()
    {
        return new DataSource()
        {
            @Override
            public Connection getConnection()
            {
                return connection();
            }

            @Override
            public Connection getConnection(String username, String password)
            {
                return connection();
            }

            @Override
            public java.io.PrintWriter getLogWriter()
            {
                return null;
            }

            @Override
            public void setLogWriter(java.io.PrintWriter out)
            {
            }

            @Override
            public void setLoginTimeout(int seconds)
            {
            }

            @Override
            public int getLoginTimeout()
            {
                return 0;
            }

            @Override
            public java.util.logging.Logger getParentLogger()
            {
                return java.util.logging.Logger.getLogger("fake-vendor");
            }

            @Override
            public <T> T unwrap(Class<T> iface) throws SQLException
            {
                throw new SQLException("不支持解包");
            }

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

    private Connection connection()
    {
        return (Connection) Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[] { Connection.class },
                (proxy, method, args) -> {
                    if ("prepareStatement".equals(method.getName())) return statement((String) args[0]);
                    if ("createStatement".equals(method.getName())) return plainStatement();
                    return defaultValue(method);
                });
    }

    /** 语句级执行：SQL 在执行时才出现，因此在这里才记录；探测类语句不回数据。 */
    private java.sql.Statement plainStatement()
    {
        return (java.sql.Statement) Proxy.newProxyInstance(getClass().getClassLoader(),
                new Class<?>[] { java.sql.Statement.class }, (proxy, method, args) -> {
                    if ("executeQuery".equals(method.getName()) || "execute".equals(method.getName())
                            || "executeUpdate".equals(method.getName()))
                    {
                        statements.add((String) args[0]);
                        return resultSet(List.of());
                    }
                    return defaultValue(method);
                });
    }

    private PreparedStatement statement(String sql)
    {
        statements.add(sql);
        List<Object> parameters = new ArrayList<>();
        return (PreparedStatement) Proxy.newProxyInstance(getClass().getClassLoader(),
                new Class<?>[] { PreparedStatement.class }, (proxy, method, args) -> {
                    switch (method.getName())
                    {
                        case "setObject", "setString", "setLong", "setInt" ->
                        {
                            int index = (Integer) args[0];
                            while (parameters.size() < index) parameters.add(null);
                            parameters.set(index - 1, args[1]);
                            return null;
                        }
                        case "executeQuery" -> { return resultSet(resolve(sql, parameters)); }
                        case "close" -> { return null; }
                        default -> { return defaultValue(method); }
                    }
                });
    }

    /** 按适配器使用的查询形态分派；参数顺序与适配器绑定顺序一致。 */
    private List<Map<String, Object>> resolve(String sql, List<Object> parameters)
    {
        String normalized = sql.toLowerCase().replaceAll("\\s+", " ");
        if (normalized.contains("from channel"))
            return channels.stream().sorted(Comparator.comparingLong(ChannelRow::devUid)
                    .thenComparingInt(ChannelRow::unitId).thenComparingInt(ChannelRow::chlId))
                    .map(row -> {
                        Map<String, Object> value = new LinkedHashMap<>();
                        value.put("dev_uid", row.devUid());
                        value.put("unit_id", row.unitId());
                        value.put("chl_id", row.chlId());
                        return value;
                    })
                    .toList();
        if (normalized.contains("from test") && normalized.contains("max(start_time)"))
            return latestTests(longValue(parameters, 0));
        if (normalized.contains("from test"))
            return latestTestForChannel(longValue(parameters, 0), intValue(parameters, 1), intValue(parameters, 2));
        if (normalized.contains("from cap_step"))
            return capStepRows(longValue(parameters, 0), longValue(parameters, 1), intValue(parameters, 2),
                    intValue(parameters, 3));
        if (normalized.contains("order by test_atime, seq_id limit"))
            return samplesAfter(tableOf(sql), parameters);
        return lastSampleOfTest(tableOf(sql), intValue(parameters, 0), intValue(parameters, 1),
                longValue(parameters, 2));
    }

    private List<Map<String, Object>> latestTests(long devUid)
    {
        Map<String, TestRow> latest = new LinkedHashMap<>();
        tests.stream().filter(row -> row.devUid() == devUid)
                .sorted(Comparator.comparing(TestRow::startTime).reversed().thenComparingLong(TestRow::testId))
                .forEach(row -> latest.putIfAbsent(row.unitId() + ":" + row.chlId(), row));
        return latest.values().stream().sorted(Comparator.comparingInt(TestRow::unitId)
                .thenComparingInt(TestRow::chlId)).map(this::testColumns).toList();
    }

    private List<Map<String, Object>> latestTestForChannel(long devUid, int unitId, int chlId)
    {
        return tests.stream().filter(row -> row.devUid() == devUid && row.unitId() == unitId && row.chlId() == chlId)
                .sorted(Comparator.comparing(TestRow::startTime).reversed().thenComparingLong(TestRow::testId))
                .limit(1).map(this::testColumns).toList();
    }

    private List<Map<String, Object>> lastSampleOfTest(String table, int unitId, int chlId, long testId)
    {
        return samples.stream().filter(row -> row.table().equals(table) && row.unitId() == unitId
                        && row.chlId() == chlId && row.testId() == testId)
                .sorted(Comparator.comparingLong(SampleRow::seqId).reversed()).limit(1)
                .map(this::sampleColumns).toList();
    }

    private List<Map<String, Object>> samplesAfter(String table, List<Object> parameters)
    {
        int unitId = intValue(parameters, 0), chlId = intValue(parameters, 1);
        // 没有带时间的下界时（水位表示界时来源里没有行）返回该通道的全部行。
        boolean bounded = parameters.size() >= 5;
        String watermark = bounded ? String.valueOf(parameters.get(2)) : null;
        long watermarkSeq = bounded ? longValue(parameters, 4) : 0L;
        return samples.stream().filter(row -> row.table().equals(table) && row.unitId() == unitId
                        && row.chlId() == chlId
                        && (!bounded || after(row.testAtime(), row.seqId(), watermark, watermarkSeq)))
                .sorted(Comparator.comparing(SampleRow::testAtime).thenComparingLong(SampleRow::seqId))
                .map(this::sampleColumns).toList();
    }

    private List<Map<String, Object>> capStepRows(long testId, long devUid, int unitId, int chlId)
    {
        return capSteps.stream().filter(row -> row.testId() == testId && row.devUid() == devUid
                        && row.unitId() == unitId && row.chlId() == chlId)
                .sorted(Comparator.comparingLong(CapStepRow::seqId)).map(this::capStepColumns).toList();
    }

    private Map<String, Object> capStepColumns(CapStepRow row)
    {
        Map<String, Object> value = new LinkedHashMap<>();
        value.put("seq_id", row.seqId());
        value.put("cycle", row.cycle());
        value.put("step_id", row.stepId());
        value.put("step_type", row.stepType());
        value.put("test_time", row.testTimeMillis());
        value.put("test_vol", row.voltage());
        value.put("test_cur", row.current());
        value.put("test_capchg", row.capacityCharge());
        value.put("test_engchg", row.energyCharge());
        value.put("test_capdchg", row.capacityDischarge());
        value.put("test_engdchg", row.energyDischarge());
        value.put("middle_vol", row.middleVoltage());
        value.put("test_atime", row.testAtime());
        return value;
    }

    private static boolean after(String atime, long seqId, String watermark, long watermarkSeq)
    {
        int time = atime.compareTo(watermark);
        return time > 0 || (time == 0 && seqId > watermarkSeq);
    }

    private static String tableOf(String sql)
    {
        java.util.regex.Matcher matcher = java.util.regex.Pattern.compile("from\\s+`([A-Za-z0-9_]+)`")
                .matcher(sql.toLowerCase());
        if (!matcher.find()) throw new IllegalStateException("假厂商库无法识别分表名：" + sql);
        return matcher.group(1);
    }

    private Map<String, Object> testColumns(TestRow row)
    {
        Map<String, Object> value = new LinkedHashMap<>();
        value.put("unit_id", row.unitId());
        value.put("chl_id", row.chlId());
        value.put("test_id", row.testId());
        value.put("main_first_table", row.firstTable());
        value.put("main_second_table", row.secondTable());
        return value;
    }

    private Map<String, Object> sampleColumns(SampleRow row)
    {
        Map<String, Object> value = new LinkedHashMap<>();
        value.put("test_id", row.testId());
        value.put("seq_id", row.seqId());
        value.put("cycle", row.cycle());
        value.put("step_id", row.stepId());
        value.put("step_type", row.stepType());
        value.put("test_time", row.testTimeMillis());
        value.put("test_vol", row.voltage());
        value.put("test_cur", row.current());
        value.put("test_capchg", row.capacityCharge());
        value.put("test_engchg", row.energyCharge());
        value.put("test_capdchg", row.capacityDischarge());
        value.put("test_engdchg", row.energyDischarge());
        value.put("test_atime", row.testAtime());
        return value;
    }

    private static ResultSet resultSet(List<Map<String, Object>> rows)
    {
        List<String> labels = rows.isEmpty() ? List.of() : List.copyOf(rows.get(0).keySet());
        int[] cursor = { -1 };
        return (ResultSet) Proxy.newProxyInstance(FakeVendorDatabase.class.getClassLoader(),
                new Class<?>[] { ResultSet.class }, (proxy, method, args) -> {
                    switch (method.getName())
                    {
                        case "next" -> { cursor[0]++; return cursor[0] < rows.size(); }
                        case "close" -> { return null; }
                        case "getLong", "getInt", "getString", "getBigDecimal" ->
                        {
                            Object value = value(rows.get(cursor[0]), labels, args[0]);
                            if (value == null) return null;
                            return switch (method.getName())
                            {
                                case "getLong" -> ((Number) value).longValue();
                                case "getInt" -> ((Number) value).intValue();
                                case "getString" -> String.valueOf(value);
                                default -> value instanceof BigDecimal decimal ? decimal
                                        : BigDecimal.valueOf(((Number) value).longValue());
                            };
                        }
                        default -> { return defaultValue(method); }
                    }
                });
    }

    private static Object value(Map<String, Object> row, List<String> labels, Object key)
    {
        if (key instanceof Integer index) return row.get(labels.get(index - 1));
        return row.get(((String) key).toLowerCase());
    }

    private static int intValue(List<Object> parameters, int index)
    {
        return ((Number) parameters.get(index)).intValue();
    }

    private static long longValue(List<Object> parameters, int index)
    {
        return ((Number) parameters.get(index)).longValue();
    }

    private static Object defaultValue(Method method)
    {
        Class<?> type = method.getReturnType();
        if (!type.isPrimitive() || type == void.class) return null;
        if (type == boolean.class) return false;
        if (type == long.class) return 0L;
        if (type == double.class) return 0d;
        if (type == float.class) return 0f;
        if (type == char.class) return (char) 0;
        return 0;
    }
}