package com.trafficaudit.security.captcha;

import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 行为验证码：按提示顺序点击立体图形。
 * 服务端直接生成每个图形的等轴测几何面（多边形/椭圆/路径），前端只负责渲染，
 * 响应中不包含任何图形类型名称，答案只保存在服务端。
 */
@Service
public class CaptchaService {

    public static final int CANVAS_W = 340;
    public static final int CANVAS_H = 148;

    private static final int SHAPE_COUNT = 6;
    private static final int ANSWER_COUNT = 4;
    private static final long TTL_MILLIS = 5 * 60 * 1000L;
    private static final int MAX_FAIL = 3;
    private static final char[] ID_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789".toCharArray();

    private static final Map<String, String> KIND_CN = new LinkedHashMap<>();

    static {
        KIND_CN.put("CUBE", "正方体");
        KIND_CN.put("BOX", "长方体");
        KIND_CN.put("CYLINDER", "圆柱");
        KIND_CN.put("CONE", "圆锥");
        KIND_CN.put("SPHERE", "球");
        KIND_CN.put("TRI_PRISM", "三棱柱");
        KIND_CN.put("PYRAMID", "金字塔");
        KIND_CN.put("HEX_PRISM", "六棱柱");
    }

    private static final String[] KINDS = KIND_CN.keySet().toArray(new String[0]);
    private static final String[] PATTERNS = {"dots", "grid", "lines", "rings", "cross", "tri"};

    private final Map<String, Challenge> store = new ConcurrentHashMap<>();
    private final Random random = new Random();

    public enum VerifyResult { OK, WRONG, NOT_FOUND, RETRY_LIMIT }

    public enum ConsumeResult { OK, WRONG, NOT_FOUND, NOT_VERIFIED }

    private static class Challenge {
        String id;
        List<String> answerKinds;
        Map<String, String> idToKind;
        boolean verified;
        long expireAt;
        int failCount;
    }

    /** 生成一组挑战，返回可直接下发前端的 JSON 结构。 */
    public Map<String, Object> generate() {
        boolean darkBg = random.nextBoolean();
        int bgHue = random.nextInt(360);
        int bgSat = 30 + random.nextInt(40);
        int bgLight = darkBg ? 14 + random.nextInt(16) : 74 + random.nextInt(16);
        String pattern = PATTERNS[random.nextInt(PATTERNS.length)];
        int patHue = (bgHue + 120 + random.nextInt(200)) % 360;

        int shapeSat = 55 + random.nextInt(30);
        int shapeLight = darkBg ? 60 + random.nextInt(18) : 28 + random.nextInt(16);
        int shapeHue = (bgHue + 30 + random.nextInt(300)) % 360;

        // 答案序列：随机取 ANSWER_COUNT 个不重复类型；其余位置用剩余类型填充
        List<String> pool = new ArrayList<>(Arrays.asList(KINDS));
        Collections.shuffle(pool, random);
        List<String> answerKinds = new ArrayList<>(pool.subList(0, ANSWER_COUNT));
        List<String> allKinds = new ArrayList<>();
        for (int i = 0; i < SHAPE_COUNT; i++) {
            if (i < ANSWER_COUNT) {
                allKinds.add(answerKinds.get(i));
            } else {
                allKinds.add(pool.get(ANSWER_COUNT + random.nextInt(pool.size() - ANSWER_COUNT)));
            }
        }
        Collections.shuffle(allKinds, random);

        int cols = 3, rows = 2;
        List<Map<String, Object>> shapes = new ArrayList<>();
        Map<String, String> idToKind = new HashMap<>();
        for (int i = 0; i < SHAPE_COUNT; i++) {
            int col = i % cols, row = i / cols;
            double x = CANVAS_W * (col + 0.5) / cols + (random.nextDouble() * 24 - 12);
            double y = CANVAS_H * (row + 0.5) / rows + (random.nextDouble() * 20 - 10);
            double size = 0.6 + random.nextDouble() * 0.35;
            double rotate = (random.nextInt(5) - 2) * 6 + (random.nextInt(5) - 2);
            String kind = allKinds.get(i);
            String id = randomId();
            idToKind.put(id, kind);
            shapes.add(buildShape(kind, id, x, y, size, rotate,
                    (shapeHue + random.nextInt(40) - 20 + 360) % 360, shapeSat, shapeLight));
        }

        Challenge ch = new Challenge();
        ch.id = randomId();
        ch.answerKinds = answerKinds;
        ch.idToKind = idToKind;
        ch.expireAt = System.currentTimeMillis() + TTL_MILLIS;
        store.put(ch.id, ch);

        Map<String, Object> data = new LinkedHashMap<>();
        data.put("captchaId", ch.id);
        List<String> prompt = new ArrayList<>();
        for (String k : answerKinds) {
            prompt.add(KIND_CN.get(k));
        }
        data.put("prompt", prompt);

        Map<String, Object> bg = new LinkedHashMap<>();
        bg.put("hue", bgHue);
        bg.put("sat", bgSat);
        bg.put("light", bgLight);
        bg.put("pattern", pattern);
        bg.put("patternHue", patHue);
        bg.put("patternSat", 50);
        bg.put("patternLight", 60);
        bg.put("patternOpacity", 0.22);
        bg.put("patternSize", 9 + random.nextInt(8));
        data.put("background", bg);
        data.put("shapes", shapes);
        return data;
    }

    /** 校验点击顺序；通过后标记已认证，登录时消费。 */
    public VerifyResult verify(String captchaId, List<String> clickIds) {
        Challenge ch = getLive(captchaId);
        if (ch == null) {
            return VerifyResult.NOT_FOUND;
        }
        if (match(ch, clickIds)) {
            ch.verified = true;
            return VerifyResult.OK;
        }
        ch.failCount++;
        if (ch.failCount >= MAX_FAIL) {
            store.remove(ch.id);
            return VerifyResult.RETRY_LIMIT;
        }
        return VerifyResult.WRONG;
    }

    /** 登录时消费验证码：一次性，校验答案并删除挑战。 */
    public ConsumeResult consume(String captchaId, List<String> clickIds) {
        Challenge ch = getLive(captchaId);
        if (ch == null) {
            return ConsumeResult.NOT_FOUND;
        }
        store.remove(ch.id);
        if (!ch.verified) {
            return ConsumeResult.NOT_VERIFIED;
        }
        if (!match(ch, clickIds)) {
            return ConsumeResult.WRONG;
        }
        return ConsumeResult.OK;
    }

    private Challenge getLive(String captchaId) {
        if (captchaId == null || captchaId.isEmpty()) {
            return null;
        }
        Challenge ch = store.get(captchaId);
        if (ch == null) {
            return null;
        }
        if (ch.expireAt < System.currentTimeMillis()) {
            store.remove(ch.id);
            return null;
        }
        return ch;
    }

    private boolean match(Challenge ch, List<String> clickIds) {
        if (clickIds == null || clickIds.isEmpty() || clickIds.size() != ch.answerKinds.size()) {
            return false;
        }
        List<String> got = new ArrayList<>();
        for (String id : clickIds) {
            String kind = ch.idToKind.get(id);
            if (kind == null) {
                return false;
            }
            got.add(kind);
        }
        return ch.answerKinds.equals(got);
    }

    private String randomId() {
        StringBuilder sb = new StringBuilder(6);
        for (int i = 0; i < 6; i++) {
            sb.append(ID_CHARS[random.nextInt(ID_CHARS.length)]);
        }
        return sb.toString();
    }

    // ==================== 等轴测几何生成 ====================

    private Map<String, Object> buildShape(String kind, String id, double x, double y, double size,
                                           double rotate, int hue, int sat, int light) {
        ShapeArt art;
        switch (kind) {
            case "CUBE": art = cube(hue, sat, light); break;
            case "BOX": art = box(hue, sat, light); break;
            case "CYLINDER": art = cylinder(hue, sat, light); break;
            case "CONE": art = cone(hue, sat, light); break;
            case "SPHERE": art = sphere(hue, sat, light); break;
            case "TRI_PRISM": art = triPrism(hue, sat, light); break;
            case "PYRAMID": art = pyramid(hue, sat, light); break;
            case "HEX_PRISM": art = hexPrism(hue, sat, light); break;
            default: art = cube(hue, sat, light);
        }
        Map<String, Object> m = new LinkedHashMap<>();
        m.put("id", id);
        m.put("x", x);
        m.put("y", y);
        m.put("size", size);
        m.put("rotate", rotate);
        m.put("hitW", art.bbox[0]);
        m.put("hitH", art.bbox[1]);
        m.put("faces", art.faces);
        return m;
    }

    private static class ShapeArt {
        List<Map<String, Object>> faces;
        double[] bbox; // {w, h} 未旋转未缩放时的包围盒

        ShapeArt(List<Map<String, Object>> faces, double w, double h) {
            this.faces = faces;
            this.bbox = new double[]{w, h};
        }
    }

    private static Map<String, Object> poly(String pts, String fill, String stroke) {
        Map<String, Object> f = new LinkedHashMap<>();
        f.put("type", "poly");
        f.put("pts", pts);
        f.put("fill", fill);
        f.put("stroke", stroke);
        f.put("sw", 1.2);
        return f;
    }

    private static Map<String, Object> ellipse(double cx, double cy, double rx, double ry,
                                               String fill, String stroke, double opacity) {
        Map<String, Object> f = new LinkedHashMap<>();
        f.put("type", "ellipse");
        f.put("cx", cx);
        f.put("cy", cy);
        f.put("rx", rx);
        f.put("ry", ry);
        f.put("fill", fill);
        f.put("stroke", stroke);
        f.put("sw", opacity > 0 ? 0 : 1.2);
        f.put("opacity", opacity);
        return f;
    }

    private static Map<String, Object> path(String d, String fill, String stroke) {
        Map<String, Object> f = new LinkedHashMap<>();
        f.put("type", "path");
        f.put("d", d);
        f.put("fill", fill);
        f.put("stroke", stroke);
        f.put("sw", 1.2);
        return f;
    }

    private static String hsl(int h, int s, int l) {
        return "hsl(" + h + "," + s + "%," + l + "%)";
    }

    private static Map<String, Object> stop(double offset, String color) {
        Map<String, Object> m = new LinkedHashMap<>();
        m.put("o", offset);
        m.put("c", color);
        return m;
    }

    private static String shade(int h, int s, int l, int delta) {
        int v = Math.max(6, Math.min(94, l + delta));
        return hsl(h, s, v);
    }

    private static String fmt(double d) {
        return String.format(Locale.ROOT, "%.1f", d);
    }

    private static String pts(double... p) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < p.length; i += 2) {
            if (sb.length() > 0) {
                sb.append(' ');
            }
            sb.append(fmt(p[i])).append(',').append(fmt(p[i + 1]));
        }
        return sb.toString();
    }

    private static ShapeArt cube(int h, int s, int l) {
        double side = 26, d = 13, cy = d / 2;
        String fillTop = shade(h, s, l, 18);
        String fillFront = hsl(h, s, l);
        String fillRight = shade(h, s, l, -14);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        faces.add(poly(pts(-side / 2, -cy, side / 2, -cy, side / 2 + d, -cy - d, -side / 2 + d, -cy - d), fillTop, stroke));
        faces.add(poly(pts(side / 2, -cy, side / 2, -cy + side, side / 2 + d, -cy + side - d, side / 2 + d, -cy - d), fillRight, stroke));
        faces.add(poly(pts(-side / 2, -cy, side / 2, -cy, side / 2, -cy + side, -side / 2, -cy + side), fillFront, stroke));
        return new ShapeArt(faces, side + d, side + d);
    }

    private static ShapeArt box(int h, int s, int l) {
        double w = 34, height = 22, d = 14, cy = d / 2;
        String fillTop = shade(h, s, l, 18);
        String fillFront = hsl(h, s, l);
        String fillRight = shade(h, s, l, -14);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        faces.add(poly(pts(-w / 2, -cy, w / 2, -cy, w / 2 + d, -cy - d, -w / 2 + d, -cy - d), fillTop, stroke));
        faces.add(poly(pts(w / 2, -cy, w / 2, -cy + height, w / 2 + d, -cy + height - d, w / 2 + d, -cy - d), fillRight, stroke));
        faces.add(poly(pts(-w / 2, -cy, w / 2, -cy, w / 2, -cy + height, -w / 2, -cy + height), fillFront, stroke));
        return new ShapeArt(faces, w + d, height + d);
    }

    private static ShapeArt cylinder(int h, int s, int l) {
        double r = 18, height = 34;
        String fillSide = hsl(h, s, l);
        String fillTop = shade(h, s, l, 18);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        String side = "M" + fmt(-r) + "," + fmt(-height / 2)
                + " L" + fmt(-r) + "," + fmt(height / 2)
                + " A" + fmt(r) + "," + fmt(r * 0.45) + ",0,0,0," + fmt(r) + "," + fmt(height / 2)
                + " L" + fmt(r) + "," + fmt(-height / 2)
                + " A" + fmt(r) + "," + fmt(r * 0.45) + ",0,0,0," + fmt(-r) + "," + fmt(-height / 2) + " Z";
        faces.add(path(side, fillSide, stroke));
        faces.add(ellipse(0, -height / 2, r, r * 0.45, fillTop, stroke, 1));
        return new ShapeArt(faces, r * 2, height + r * 0.9);
    }

    private static ShapeArt cone(int h, int s, int l) {
        double r = 20, height = 38;
        double apexY = -height;
        double cy = (-height + r * 0.45) / 2;
        String fillBase = shade(h, s, l, -14);
        String fillSide = hsl(h, s, l);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        faces.add(ellipse(0, -cy, r, r * 0.45, fillBase, stroke, 1));
        String side = "M" + fmt(0) + "," + fmt(apexY - cy)
                + " L" + fmt(-r) + "," + fmt(-cy)
                + " A" + fmt(r) + "," + fmt(r * 0.45) + ",0,0,1," + fmt(r) + "," + fmt(-cy) + " Z";
        faces.add(path(side, fillSide, stroke));
        return new ShapeArt(faces, r * 2, height + r * 0.45);
    }

    private static ShapeArt sphere(int h, int s, int l) {
        double r = 21;
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        Map<String, Object> grad = new LinkedHashMap<>();
        grad.put("id", "g");
        grad.put("cx", 0.35);
        grad.put("cy", 0.32);
        grad.put("r", 0.85);
        List<Map<String, Object>> stops = new ArrayList<>();
        stops.add(stop(0, shade(h, s, l, 26)));
        stops.add(stop(0.5, hsl(h, s, l)));
        stops.add(stop(1, shade(h, s, l, -20)));
        grad.put("stops", stops);
        Map<String, Object> f = new LinkedHashMap<>();
        f.put("type", "radial");
        f.put("cx", 0.0);
        f.put("cy", 0.0);
        f.put("r", r);
        f.put("grad", grad);
        f.put("stroke", stroke);
        f.put("sw", 1.2);
        faces.add(f);
        faces.add(ellipse(-r * 0.38, -r * 0.45, r * 0.3, r * 0.2, "#ffffff", "none", 0.65));
        faces.add(ellipse(r * 0.25, r * 0.45, r * 0.55, r * 0.2, shade(h, s, l, -32), "none", 0.45));
        return new ShapeArt(faces, r * 2, r * 2);
    }

    private static ShapeArt triPrism(int h, int s, int l) {
        double w = 34, height = 30, depth = 12;
        double cy = (depth * 0.5 + height) / 2;
        String fillTop = shade(h, s, l, 18);
        String fillRight = hsl(h, s, l);
        String fillLeft = shade(h, s, l, -14);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        faces.add(poly(pts(0, -cy + depth * 0.5, w / 2, -cy, -w / 2, -cy), fillTop, stroke));
        faces.add(poly(pts(0, -cy + depth * 0.5, w / 2, -cy, w / 2, -cy + height, 0, -cy + depth * 0.5 + height), fillRight, stroke));
        faces.add(poly(pts(0, -cy + depth * 0.5, -w / 2, -cy, -w / 2, -cy + height, 0, -cy + depth * 0.5 + height), fillLeft, stroke));
        return new ShapeArt(faces, w, depth * 0.5 + height);
    }

    private static ShapeArt pyramid(int h, int s, int l) {
        double half = 26, height = 34;
        double cy = (-height + half) / 2;
        String fillBase = shade(h, s, l, -20);
        String fillRight = hsl(h, s, l);
        String fillLeft = shade(h, s, l, -10);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        faces.add(poly(pts(0, -cy, half, -cy + half * 0.5, 0, -cy + half, -half, -cy + half * 0.5), fillBase, stroke));
        faces.add(poly(pts(0, -cy - height, 0, -cy, -half, -cy + half * 0.5), fillLeft, stroke));
        faces.add(poly(pts(0, -cy - height, 0, -cy, half, -cy + half * 0.5), fillRight, stroke));
        return new ShapeArt(faces, half * 2, height + half);
    }

    private static ShapeArt hexPrism(int h, int s, int l) {
        double r = 22, height = 28, ry = r * 0.433;
        double cy = ry;
        String fillTop = shade(h, s, l, 18);
        String fillR = hsl(h, s, l);
        String fillF = shade(h, s, l, -12);
        String fillL = shade(h, s, l, -22);
        String stroke = shade(h, s, l, -30);
        List<Map<String, Object>> faces = new ArrayList<>();
        faces.add(poly(pts(r, -cy, r * 0.5, -cy + ry, -r * 0.5, -cy + ry, -r, -cy,
                -r * 0.5, -cy - ry, r * 0.5, -cy - ry), fillTop, stroke));
        faces.add(poly(pts(r, -cy, r * 0.5, -cy + ry, r * 0.5, -cy + ry + height, r, -cy + height), fillR, stroke));
        faces.add(poly(pts(r * 0.5, -cy + ry, -r * 0.5, -cy + ry, -r * 0.5, -cy + ry + height, r * 0.5, -cy + ry + height), fillF, stroke));
        faces.add(poly(pts(-r * 0.5, -cy + ry, -r, -cy, -r, -cy + height, -r * 0.5, -cy + ry + height), fillL, stroke));
        return new ShapeArt(faces, r * 2, ry * 2 + height);
    }
}