/*
 * ============================================================================
 * SqlRecordingAspect —— 旧系统侧 SQL 录制切面(交付物,非本工程编译单元)
 * ----------------------------------------------------------------------------
 * 部署目标:正在运行的旧系统(Spring 3.1 + JDK 6 + OSGi)。因旧系统环境本机不可得,
 *           本文件以「源码 + XML 配置」形式交付,在旧系统侧编译部署。
 *
 * 作用:拦截旧系统 JdbcTemplate 的 query* / update / execute 调用,把
 *       SQL 文本 + 参数 + 结果集(行列值)逐条写成 JSONL,作为 C1 逐行对拍的
 *       "基线侧"录制流量。重放端见 com.eip4.platform.parity.replay.ReplayRunner,
 *       diff 内核见 com.eip4.platform.parity.diff.RowDiff。
 *
 * 约束(适配旧栈):
 *   - 仅用 JDK 6 + Spring 3.1 AOP(无 lambda、无 try-with-resources、无 java.time);
 *   - 无第三方 JSON 依赖时,手写极简 JSON 串行化(见 JsonOut),避免给旧系统引依赖;
 *   - 切面只读不改:绝不修改 SQL、参数或返回值,零侵入旧行为;
 *   - 输出 JSONL 与 SqlRecord 字段对齐(op/sql/params/columns/rows/affectedRows/ts/entity)。
 *
 * 装配:用 Spring 3.1 AOP XML(<aop:config> + <aop:aspect>),见同目录《集成说明.md》。
 * ============================================================================
 */
package com.dsasp.parity.recorder;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.Writer;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.jdbc.core.RowMapper;

/**
 * 环绕通知:对 JdbcTemplate 的查询/更新/执行方法录制。
 * 用 around advice 包住目标方法:query* 录结果集,update/execute 录影响行数。
 */
public class SqlRecordingAspect {

    /** 录制文件路径(JSONL,每行一条),由 XML setter 注入。 */
    private String outputFile = "/var/log/eip-legacy/sql-record.jsonl";

    /** 同一进程并发写需同步(旧系统 JdbcTemplate 多线程)。 */
    private final Object writeLock = new Object();

    public void setOutputFile(String outputFile) {
        this.outputFile = outputFile;
    }

    /**
     * 环绕 JdbcTemplate.query*(...) —— 录 SQL + 参数 + 结果集行列值。
     * 切点表达式见 XML;此方法签名匹配 around advice。
     */
    public Object aroundQuery(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object[] args = pjp.getArgs();
        String sql = firstString(args);
        Object result = pjp.proceed(); // 不改返回值
        try {
            SqlRecord rec = new SqlRecord("query", sql);
            rec.ts = start;
            rec.entity = guessEntity(sql);
            extractParams(args, rec.params);
            // result 可能是 List<Map> / List<Object> / SqlRowSet,按类型尽力转录
            captureRows(result, rec);
            write(rec);
        } catch (Throwable recErr) {
            // 录制失败绝不影响业务:吞掉并继续
            System.err.println("[SqlRecordingAspect] record query failed: " + recErr.getMessage());
        }
        return result;
    }

    /** 环绕 JdbcTemplate.update(...) / execute(...) —— 录 SQL + 参数 + 影响行数。 */
    public Object aroundWrite(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        Object[] args = pjp.getArgs();
        String sql = firstString(args);
        Object result = pjp.proceed();
        try {
            String op = pjp.getSignature().getName().startsWith("execute") ? "execute" : "update";
            SqlRecord rec = new SqlRecord(op, sql);
            rec.ts = start;
            rec.entity = guessEntity(sql);
            extractParams(args, rec.params);
            if (result instanceof Integer) {
                rec.affectedRows = ((Integer) result).longValue();
            }
            write(rec);
        } catch (Throwable recErr) {
            System.err.println("[SqlRecordingAspect] record write failed: " + recErr.getMessage());
        }
        return result;
    }

    // ---- 结果集转录(尽力按运行期类型)----

    @SuppressWarnings({"unchecked", "rawtypes"})
    private void captureRows(Object result, SqlRecord rec) {
        if (result instanceof List) {
            List list = (List) result;
            for (int i = 0; i < list.size(); i++) {
                Object row = list.get(i);
                if (row instanceof java.util.Map) {
                    java.util.Map<String, Object> m = (java.util.Map<String, Object>) row;
                    if (rec.columns.isEmpty()) {
                        rec.columns.addAll(upper(m.keySet()));
                    }
                    java.util.Map<String, Object> norm = new java.util.LinkedHashMap<String, Object>();
                    java.util.Iterator it = m.entrySet().iterator();
                    while (it.hasNext()) {
                        java.util.Map.Entry e = (java.util.Map.Entry) it.next();
                        norm.put(String.valueOf(e.getKey()).toUpperCase(), e.getValue());
                    }
                    rec.rows.add(norm);
                }
            }
        }
        // 若旧系统返回 SqlRowSet,可在此分支用 SqlRowSetMetaData 取列后逐行 getObject;
        // 旧系统 POJOService 已物化为 List<GeneralPOJO>,推荐在更高层(POJOService.listSelect
        // 返回值)挂另一切面,把 GeneralPOJO.toRow() 平面 map 录入,语义与新引擎 EntityController 完全对齐。
    }

    /** RowMapper 形式查询的列名兜底(部分 query 重载传 RowMapper)。 */
    private List<String> mapperColumns(RowMapper<?> mapper) {
        return new ArrayList<String>();
    }

    // ---- 工具 ----

    private static String firstString(Object[] args) {
        if (args != null) {
            for (int i = 0; i < args.length; i++) {
                if (args[i] instanceof String) {
                    return (String) args[i];
                }
            }
        }
        return null;
    }

    private static void extractParams(Object[] args, List<Object> out) {
        if (args == null) {
            return;
        }
        for (int i = 0; i < args.length; i++) {
            Object a = args[i];
            if (a instanceof Object[]) {
                Object[] arr = (Object[]) a;
                for (int j = 0; j < arr.length; j++) {
                    out.add(arr[j]);
                }
            } else if (a != null && !(a instanceof String) && !(a instanceof RowMapper)
                    && !(a instanceof Class)) {
                // 跳过 SQL 串、RowMapper、返回类型;其余视为绑定参数
                out.add(a);
            }
        }
    }

    /** 从 SQL 粗解析主表名(FROM xxx),仅用于报告分组,非语义关键。 */
    private static String guessEntity(String sql) {
        if (sql == null) {
            return null;
        }
        String s = sql.toUpperCase();
        int from = s.indexOf(" FROM ");
        if (from < 0) {
            int into = s.indexOf(" INTO ");
            int upd = s.indexOf("UPDATE ");
            if (into >= 0) {
                return token(s, into + 6);
            }
            if (upd >= 0) {
                return token(s, upd + 7);
            }
            return null;
        }
        return token(s, from + 6);
    }

    private static String token(String s, int start) {
        int i = start;
        while (i < s.length() && s.charAt(i) == ' ') {
            i++;
        }
        int j = i;
        while (j < s.length() && (Character.isLetterOrDigit(s.charAt(j)) || s.charAt(j) == '_')) {
            j++;
        }
        return j > i ? s.substring(i, j) : null;
    }

    private static List<String> upper(java.util.Set<String> keys) {
        List<String> out = new ArrayList<String>();
        java.util.Iterator<String> it = keys.iterator();
        while (it.hasNext()) {
            out.add(it.next().toUpperCase());
        }
        return out;
    }

    private void write(SqlRecord rec) throws Exception {
        String line = JsonOut.toJson(rec);
        synchronized (writeLock) {
            Writer w = null;
            try {
                w = new BufferedWriter(new FileWriter(outputFile, true));
                w.write(line);
                w.write("\n");
            } finally {
                if (w != null) {
                    w.close();
                }
            }
        }
    }
}
