package lujing;

import java.awt.geom.Line2D;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.locationtech.jts.geom.Coordinate;
import org.locationtech.jts.geom.Envelope;
import org.locationtech.jts.geom.Geometry;
import org.locationtech.jts.geom.GeometryFactory;
import org.locationtech.jts.geom.LineString;
import org.locationtech.jts.geom.LinearRing;
import org.locationtech.jts.geom.MultiLineString;
import org.locationtech.jts.geom.MultiPolygon;
import org.locationtech.jts.geom.Polygon;
import org.locationtech.jts.operation.union.CascadedPolygonUnion;

/**
 * 割草路径规划实用类，供其他项目直接调用。
 * 提供字符串入参的割草路径生成能力，并封装必要的解析与几何处理逻辑。
 */
public final class Lunjingguihua {

    private Lunjingguihua() {
        throw new IllegalStateException("Utility class");
    }

    /**
     * 生成割草路径段列表。
     *
     * @param polygonCoords   多边形边界坐标，格式如 "x1,y1;x2,y2;..."（米）
     * @param obstaclesCoords 障碍物坐标，支持多个括号段或圆形定义，例 "(x1,y1;x2,y2)(cx,cy;px,py)"
     * @param mowingWidth     割草宽度字符串，米单位，允许保留两位小数
     * @param safetyDistStr   安全距离字符串，米单位。路径将与边界和障碍物保持此距离。
     * @param modeStr         割草模式，"0"/空为平行线，"1" 或 "spiral" 表示螺旋模式（当前仅平行线实现）
     * @return 路径段列表，按行驶顺序排列
     */
    public static List<PathSegment> generatePathSegments(String polygonCoords,
                                                         String obstaclesCoords,
                                                         String mowingWidth,
                                                         String safetyDistStr,
                                                         String modeStr) {
        List<Coordinate> polygon = parseCoordinates(polygonCoords);
        if (polygon.size() < 4) {
            throw new IllegalArgumentException("多边形坐标数量不足，至少需要三个点");
        }

        double width = parseDoubleOrDefault(mowingWidth, 2.0);
        if (width <= 0) {
            throw new IllegalArgumentException("割草宽度必须大于 0");
        }
        
        // 解析安全距离，如果未设置或无效，默认为 NaN (在 PlannerCore 中处理默认值)
        double safetyDistance = parseDoubleOrDefault(safetyDistStr, Double.NaN);

        List<List<Coordinate>> obstacles = parseObstacles(obstaclesCoords);
        String mode = normalizeMode(modeStr);

        PlannerCore planner = new PlannerCore(polygon, width, safetyDistance, mode, obstacles);
        return planner.generate();
    }

    /**
     * 保持向后兼容的重载方法（不带 safeDistance，使用默认计算）
     */
    public static List<PathSegment> generatePathSegments(String polygonCoords,
                                                         String obstaclesCoords,
                                                         String mowingWidth,
                                                         String modeStr) {
        return generatePathSegments(polygonCoords, obstaclesCoords, mowingWidth, null, modeStr);
    }

    /**
     * 通过字符串参数生成割草路径坐标。
     *
     * @param polygonCoords   多边形边界坐标，格式如 "x1,y1;x2,y2;..."（米）
     * @param obstaclesCoords 障碍物坐标，支持多个括号段或圆形定义，例 "(x1,y1;x2,y2)(cx,cy;px,py)"
     * @param mowingWidth     割草宽度字符串，米单位，允许保留两位小数
     * @param safetyDistStr   安全距离字符串，米单位。
     * @param modeStr         割草模式，"0"/空为平行线，"1" 或 "spiral" 表示螺旋模式（当前仅平行线实现）
     * @return 连续路径坐标字符串，顺序紧跟割草机行进路线
     */
    public static String generatePathFromStrings(String polygonCoords,
                                                 String obstaclesCoords,
                                                 String mowingWidth,
                                                 String safetyDistStr,
                                                 String modeStr) {
        List<PathSegment> segments = generatePathSegments(polygonCoords, obstaclesCoords, mowingWidth, safetyDistStr, modeStr);
        return formatPathSegments(segments);
    }
    
    /**
     * 保持向后兼容的重载方法
     */
    public static String generatePathFromStrings(String polygonCoords,
                                                 String obstaclesCoords,
                                                 String mowingWidth,
                                                 String modeStr) {
        return generatePathFromStrings(polygonCoords, obstaclesCoords, mowingWidth, null, modeStr);
    }

    /**
     * 将路径段列表转换为坐标字符串。
     */
    public static String formatPathSegments(List<PathSegment> path) {
        if (path == null || path.isEmpty()) {
            return "";
        }
        StringBuilder sb = new StringBuilder();
        Coordinate last = null;
        for (PathSegment segment : path) {
            if (!equals2D(last, segment.start)) {
                appendPoint(sb, segment.start);
                last = new Coordinate(segment.start);
            }
            if (!equals2D(last, segment.end)) {
                appendPoint(sb, segment.end);
                last = new Coordinate(segment.end);
            }
        }
        return sb.toString();
    }

    /**
     * 解析坐标字符串。
     */
    public static List<Coordinate> parseCoordinates(String s) {
        List<Coordinate> list = new ArrayList<>();
        if (s == null || s.trim().isEmpty()) {
            return list;
        }
        String[] pts = s.split("[;\\s]+");
        for (String p : pts) {
            String trimmed = p.trim().replace("(", "").replace(")", "");
            if (trimmed.isEmpty()) {
                continue;
            }
            String[] xy = trimmed.split("[,，\\s]+");
            if (xy.length >= 2) {
                try {
                    list.add(new Coordinate(Double.parseDouble(xy[0].trim()),
                                            Double.parseDouble(xy[1].trim())));
                } catch (NumberFormatException ex) {
                    System.err.println("坐标解析失败: " + trimmed);
                }
            }
        }
        if (list.size() > 2 && !list.get(0).equals2D(list.get(list.size() - 1))) {
            list.add(new Coordinate(list.get(0)));
        }
        return list;
    }

    /**
     * 解析障碍物字符串，兼容多障碍物与圆形定义。
     */
    public static List<List<Coordinate>> parseObstacles(String str) {
        List<List<Coordinate>> obs = new ArrayList<>();
        if (str == null || str.trim().isEmpty()) {
            return obs;
        }
        java.util.regex.Pattern pattern = java.util.regex.Pattern.compile("\\(([^)]+)\\)");
        java.util.regex.Matcher matcher = pattern.matcher(str);
        while (matcher.find()) {
            List<Coordinate> coords = parseCoordinates(matcher.group(1));
            if (coords.size() >= 3) {
                obs.add(coords);
            } else if (coords.size() == 2) {
                List<Coordinate> circle = approximateCircle(coords.get(0), coords.get(1));
                if (!circle.isEmpty()) {
                    obs.add(circle);
                }
            }
        }
        if (obs.isEmpty()) {
            List<Coordinate> coords = parseCoordinates(str);
            if (coords.size() >= 3) {
                obs.add(coords);
            } else if (coords.size() == 2) {
                List<Coordinate> circle = approximateCircle(coords.get(0), coords.get(1));
                if (!circle.isEmpty()) {
                    obs.add(circle);
                }
            }
        }
        return obs;
    }

    private static double parseDoubleOrDefault(String value, double defaultValue) {
        if (value == null || value.trim().isEmpty()) {
            return defaultValue;
        }
        try {
            return Double.parseDouble(value.trim());
        } catch (NumberFormatException ex) {
            throw new IllegalArgumentException("格式不正确: " + value, ex);
        }
    }

    private static String normalizeMode(String modeStr) {
        if (modeStr == null) {
            return "parallel";
        }
        String trimmed = modeStr.trim().toLowerCase();
        if ("1".equals(trimmed) || "spiral".equals(trimmed)) {
            return "spiral";
        }
        return "parallel";
    }

    private static boolean equals2D(Coordinate a, Coordinate b) {
        if (a == b) {
            return true;
        }
        if (a == null || b == null) {
            return false;
        }
        return a.equals2D(b);
    }

    private static void appendPoint(StringBuilder sb, Coordinate point) {
        if (sb.length() > 0) {
            sb.append(";");
        }
        sb.append(String.format("%.2f,%.2f", point.x, point.y));
    }

    private static List<Coordinate> approximateCircle(Coordinate center, Coordinate edge) {
        double radius = center.distance(edge);
        if (radius <= 0) {
            return Collections.emptyList();
        }
        int segments = 36;
        List<Coordinate> circle = new ArrayList<>(segments + 1);
        for (int i = 0; i < segments; i++) {
            double angle = 2 * Math.PI * i / segments;
            double x = center.x + radius * Math.cos(angle);
            double y = center.y + radius * Math.sin(angle);
            circle.add(new Coordinate(x, y));
        }
        circle.add(new Coordinate(circle.get(0)));
        return circle;
    }

    /**
     * 路径段数据结构。
     */
    public static final class PathSegment {
        public Coordinate start;
        public Coordinate end;
        public boolean isMowing;
        public boolean isStartPoint;
        public boolean isEndPoint;

        public PathSegment(Coordinate start, Coordinate end, boolean isMowing) {
            this.start = start;
            this.end = end;
            this.isMowing = isMowing;
        }

        public void setAsStartPoint() {
            this.isStartPoint = true;
        }

        public void setAsEndPoint() {
            this.isEndPoint = true;
        }

        @Override
        public String toString() {
            return String.format("PathSegment[(%.2f,%.2f)->(%.2f,%.2f) mowing=%b start=%b end=%b]",
                    start.x, start.y, end.x, end.y, isMowing, isStartPoint, isEndPoint);
        }
    }

    /**
     * 内部核心规划器，实现与 MowingPathPlanner 等效的逻辑。
     */
    static final class PlannerCore {
        private final List<Coordinate> polygon;
        private final double width;
        private final double safetyDistance; // 新增安全距离字段
        private final String mode;
        private final List<List<Coordinate>> obstacles;
        private final GeometryFactory gf = new GeometryFactory();

        PlannerCore(List<Coordinate> polygon, double width, double safetyDistance, String mode, List<List<Coordinate>> obstacles) {
            this.polygon = polygon;
            this.width = width;
            this.mode = mode;
            this.obstacles = obstacles != null ? obstacles : new ArrayList<>();
            
            // 初始化安全距离逻辑
            if (Double.isNaN(safetyDistance)) {
                // 如果未提供，使用默认值：宽度的一半 + 0.05米
                this.safetyDistance = width / 2.0 + 0.05;
            } else {
                // 如果提供了，使用提供的值，但至少要保证机器中心不碰壁（宽度一半）
                // 允许用户设置比 width/2 更大的值来远离边界
                this.safetyDistance = Math.max(safetyDistance, width / 2.0);
            }
        }
        
        // 兼容旧构造函数
        PlannerCore(List<Coordinate> polygon, double width, String mode, List<List<Coordinate>> obstacles) {
            this(polygon, width, Double.NaN, mode, obstacles);
        }

        List<PathSegment> generate() {
            // 如果有障碍物，使用带障碍物避让的路径规划器
            if (!obstacles.isEmpty()) {
                // 使用计算好的安全距离
                ObstaclePathPlanner obstaclePlanner = new ObstaclePathPlanner(
                    polygon, width, mode, obstacles, this.safetyDistance);
                return obstaclePlanner.generate();
            }
            
            // 没有障碍物时使用原有逻辑
            if ("spiral".equals(mode)) {
                return generateSpiralPath();
            }
            return generateParallelPath();
        }

        List<PathSegment> generateParallelPath() {
            List<PathSegment> path = new ArrayList<>();
            Geometry safeArea = buildSafeArea();
            if (safeArea == null || safeArea.isEmpty()) {
                System.err.println("安全区域为空，无法生成路径");
                return path;
            }

            LineSegment longest = findLongestEdge(polygon);
            Vector2D baseDir = new Vector2D(longest.end.x - longest.start.x,
                                            longest.end.y - longest.start.y).normalize();
            Vector2D perp = baseDir.rotate90CCW();
            Vector2D baseStartVec = new Vector2D(longest.start.x, longest.start.y);
            double baseProjection = perp.dot(baseStartVec); 

            double minProj = Double.POSITIVE_INFINITY;
            double maxProj = Double.NEGATIVE_INFINITY;
            Coordinate[] supportCoords = safeArea.getCoordinates();
            if (supportCoords != null && supportCoords.length > 0) {
                for (Coordinate coord : supportCoords) {
                    double projection = perp.dot(new Vector2D(coord.x, coord.y)) - baseProjection;
                    if (projection < minProj) {
                        minProj = projection;
                    }
                    if (projection > maxProj) {
                        maxProj = projection;
                    }
                }
            } else {
                Envelope env = safeArea.getEnvelopeInternal();
                minProj = perp.dot(new Vector2D(env.getMinX(), env.getMinY())) - baseProjection;
                maxProj = perp.dot(new Vector2D(env.getMaxX(), env.getMaxY())) - baseProjection;
            }
            if (minProj > maxProj) {
                double tmp = minProj;
                minProj = maxProj;
                maxProj = tmp;
            }
            double first = minProj - width / 2.0;

            Geometry originalPoly = createPolygonFromCoordinates(polygon);
            Coordinate lastEnd = null;
            int idx = 0;

            for (double offset = first; offset <= maxProj + width / 2.0; offset += width) {
                Line2D.Double raw = createInfiniteLine(longest, perp, offset);
                List<Line2D.Double> segs = clipLineToPolygon(raw, safeArea);
                if (segs.isEmpty()) {
                    continue;
                }

                List<Line2D.Double> finalSegs = new ArrayList<>();
                for (Line2D.Double seg : segs) {
                    finalSegs.addAll(clipLineToPolygon(seg, originalPoly));
                }
                if (finalSegs.isEmpty()) {
                    continue;
                }

                finalSegs.sort((a, b) -> Double.compare(baseDir.dot(midV(a)), baseDir.dot(midV(b))));
                boolean even = (idx % 2 == 0);
                for (Line2D.Double seg : finalSegs) {
                    Coordinate entry = even ? new Coordinate(seg.x1, seg.y1)
                                            : new Coordinate(seg.x2, seg.y2);
                    Coordinate exit = even ? new Coordinate(seg.x2, seg.y2)
                                           : new Coordinate(seg.x1, seg.y1);

                    if (lastEnd != null && lastEnd.distance(entry) > 1e-3) {
                        path.add(new PathSegment(lastEnd, entry, false));
                    }

                    PathSegment mowingSeg = new PathSegment(entry, exit, true);
                    if (path.isEmpty()) {
                        mowingSeg.setAsStartPoint();
                    }
                    path.add(mowingSeg);
                    lastEnd = exit;
                }
                idx++;
            }

            if (!path.isEmpty()) {
                path.get(path.size() - 1).setAsEndPoint();
            }

            postProcess(path);
            return path;
        }

        List<PathSegment> generateSpiralPath() {
            Geometry safeArea = buildSafeArea();
            if (safeArea == null || safeArea.isEmpty()) {
                System.err.println("安全区域为空，无法生成螺旋路径");
                return new ArrayList<>();
            }

            List<PathSegment> spiral = luoxuan.generateSpiralPath(safeArea, width);
            if (spiral.isEmpty()) {
                return spiral;
            }

            postProcess(spiral);
            PathSegment firstMowing = null;
            PathSegment endCandidate = null;
            for (int i = 0; i < spiral.size(); i++) {
                PathSegment seg = spiral.get(i);
                if (seg != null && seg.isMowing) {
                    if (firstMowing == null) {
                        firstMowing = seg;
                    }
                    endCandidate = seg;
                }
            }
            if (firstMowing != null) {
                firstMowing.setAsStartPoint();
            }
            if (endCandidate != null && endCandidate != firstMowing) {
                endCandidate.setAsEndPoint();
            }
            return spiral;
        }

        private Geometry buildSafeArea() {
            try {
                Coordinate[] coords = polygon.toArray(new Coordinate[0]);
                if (!coords[0].equals2D(coords[coords.length - 1])) {
                    coords = Arrays.copyOf(coords, coords.length + 1);
                    coords[coords.length - 1] = coords[0];
                }
                Polygon origin = gf.createPolygon(gf.createLinearRing(coords));
                Geometry result = origin;

                if (!obstacles.isEmpty()) {
                    List<Geometry> obsGeom = new ArrayList<>();
                    for (List<Coordinate> obs : obstacles) {
                        Geometry g = createPolygonFromCoordinates(obs);
                        if (g != null && !g.isEmpty()) {
                            obsGeom.add(g);
                        }
                    }
                    if (!obsGeom.isEmpty()) {
                        Geometry union = CascadedPolygonUnion.union(obsGeom);
                        result = origin.difference(union);
                    }
                }

                // 修改：使用传入的 safetyDistance 来进行边界内缩
                // 之前是 width / 2.0，现在使用 this.safetyDistance
                // 这确保了路径规划区域与边界保持用户指定的距离
                Geometry shrunk = shrinkStraight(result, this.safetyDistance);
                return shrunk.isEmpty() ? result : shrunk;
            } catch (Exception ex) {
                System.err.println("构建安全区域失败: " + ex.getMessage());
                return gf.createPolygon();
            }
        }

        private LineSegment findLongestEdge(List<Coordinate> ring) {
            double max = -1.0;
            LineSegment best = null;
            for (int i = 0; i < ring.size() - 1; i++) {
                double d = ring.get(i).distance(ring.get(i + 1));
                if (d > max) {
                    max = d;
                    best = new LineSegment(ring.get(i), ring.get(i + 1), i);
                }
            }
            return best;
        }

        private Line2D.Double createInfiniteLine(LineSegment base, Vector2D perp, double offset) {
            Vector2D baseStart = new Vector2D(base.start.x, base.start.y);
            Vector2D baseDir = new Vector2D(base.end.x - base.start.x,
                                            base.end.y - base.start.y).normalize();
            Vector2D center = baseStart.add(perp.mul(offset));
            double ext = 1.5 * diagonalLength();
            Vector2D p1 = center.sub(baseDir.mul(ext));
            Vector2D p2 = center.add(baseDir.mul(ext));
            return new Line2D.Double(p1.x, p1.y, p2.x, p2.y);
        }

        private List<Line2D.Double> clipLineToPolygon(Line2D.Double line, Geometry poly) {
            List<Line2D.Double> list = new ArrayList<>();
            LineString ls = gf.createLineString(new Coordinate[]{
                    new Coordinate(line.x1, line.y1),
                    new Coordinate(line.x2, line.y2)
            });
            Geometry inter = poly.intersection(ls);
            if (inter.isEmpty()) {
                return list;
            }

            if (inter instanceof LineString) {
                addCoords((LineString) inter, list);
            } else if (inter instanceof MultiLineString) {
                MultiLineString mls = (MultiLineString) inter;
                for (int i = 0; i < mls.getNumGeometries(); i++) {
                    addCoords((LineString) mls.getGeometryN(i), list);
                }
            }
            return list;
        }

        private void addCoords(LineString ls, List<Line2D.Double> bucket) {
            Coordinate[] cs = ls.getCoordinateSequence().toCoordinateArray();
            for (int i = 0; i < cs.length - 1; i++) {
                bucket.add(new Line2D.Double(cs[i].x, cs[i].y, cs[i + 1].x, cs[i + 1].y));
            }
        }

        private Geometry createPolygonFromCoordinates(List<Coordinate> coords) {
            if (coords.size() < 3) {
                return gf.createPolygon();
            }
            List<Coordinate> closed = new ArrayList<>(coords);
            if (!closed.get(0).equals2D(closed.get(closed.size() - 1))) {
                closed.add(new Coordinate(closed.get(0)));
            }
            LinearRing shell = gf.createLinearRing(closed.toArray(new Coordinate[0]));
            Polygon polygonGeom = gf.createPolygon(shell);
            return polygonGeom.isValid() ? polygonGeom : (Polygon) polygonGeom.buffer(0);
        }

        private double diagonalLength() {
            double minX = polygon.stream().mapToDouble(c -> c.x).min().orElse(0);
            double maxX = polygon.stream().mapToDouble(c -> c.x).max().orElse(0);
            double minY = polygon.stream().mapToDouble(c -> c.y).min().orElse(0);
            double maxY = polygon.stream().mapToDouble(c -> c.y).max().orElse(0);
            return Math.hypot(maxX - minX, maxY - minY);
        }

        private Vector2D midV(Line2D.Double l) {
            return new Vector2D((l.x1 + l.x2) / 2.0, (l.y1 + l.y2) / 2.0);
        }

        private void postProcess(List<PathSegment> path) {
            if (path == null || path.isEmpty()) {
                return;
            }
            List<PathSegment> tmp = new ArrayList<>(path);
            path.clear();
            Coordinate prevEnd = null;
            for (PathSegment seg : tmp) {
                if (prevEnd != null && seg.start.distance(prevEnd) < 1e-3) {
                    seg.start = prevEnd;
                }
                if (!seg.isMowing && !path.isEmpty()) {
                    PathSegment last = path.get(path.size() - 1);
                    if (!last.isMowing && isCollinear(last.start, last.end, seg.end)) {
                        last.end = seg.end;
                        prevEnd = seg.end;
                        continue;
                    }
                }
                path.add(seg);
                prevEnd = seg.end;
            }
        }

        private boolean isCollinear(Coordinate a, Coordinate b, Coordinate c) {
            double dx1 = b.x - a.x;
            double dy1 = b.y - a.y;
            double dx2 = c.x - b.x;
            double dy2 = c.y - b.y;
            double cross = dx1 * dy2 - dy1 * dx2;
            return Math.abs(cross) < 1e-6;
        }

        private Geometry shrinkStraight(Geometry outer, double dist) {
            Geometry buf = outer.buffer(-dist);
            if (buf.isEmpty()) {
                return buf;
            }

            Geometry poly = (buf instanceof Polygon) ? buf
                    : (buf instanceof MultiPolygon) ? ((MultiPolygon) buf).getGeometryN(0) : null;
            if (!(poly instanceof Polygon)) {
                return buf;
            }

            Coordinate[] ring = ((Polygon) poly).getExteriorRing().getCoordinateSequence().toCoordinateArray();
            List<Coordinate> straight = new ArrayList<>();
            final double EPS = 1e-3;
            for (int i = 0; i < ring.length - 1; i++) {
                Coordinate prev = (i == 0) ? ring[ring.length - 2] : ring[i - 1];
                Coordinate curr = ring[i];
                Coordinate next = ring[i + 1];
                double cross = Math.abs((next.x - curr.x) * (curr.y - prev.y)
                                      - (curr.x - prev.x) * (next.y - curr.y));
                if (cross > EPS) {
                    straight.add(curr);
                }
            }
            if (straight.isEmpty()) {
                return buf;
            }
            straight.add(new Coordinate(straight.get(0)));
            return straight.size() < 4 ? gf.createPolygon()
                    : gf.createPolygon(gf.createLinearRing(straight.toArray(new Coordinate[0])));
        }
    }

    private static final class Vector2D {
        final double x;
        final double y;

        Vector2D(double x, double y) {
            this.x = x;
            this.y = y;
        }

        Vector2D normalize() {
            double len = Math.hypot(x, y);
            if (len < 1e-12) {
                return new Vector2D(1, 0);
            }
            return new Vector2D(x / len, y / len);
        }

        Vector2D rotate90CCW() {
            return new Vector2D(-y, x);
        }

        double dot(Vector2D v) {
            return x * v.x + y * v.y;
        }

        Vector2D sub(Vector2D v) {
            return new Vector2D(x - v.x, y - v.y);
        }

        Vector2D add(Vector2D v) {
            return new Vector2D(x + v.x, y + v.y);
        }

        Vector2D mul(double k) {
            return new Vector2D(x * k, y * k);
        }
    }

    private static final class LineSegment {
        final Coordinate start;
        final Coordinate end;
        final int index;

        LineSegment(Coordinate start, Coordinate end, int index) {
            this.start = start;
            this.end = end;
            this.index = index;
        }
    }
}