package lujing;

import java.util.ArrayList;
import java.util.List;

public class Qufenxingzhuang {

    // 容差阈值：sin(角度)。
    // 0.05 大约对应 2.8度。意味着小于3度的微小凹陷或凸起会被忽略，视为直线。
    // 如果您觉得判断依然太严，可以将此值调大到 0.1 (约5.7度)。
    private static final double ANGLE_TOLERANCE = 0.1;

    // 判断草地类型的主方法
    public int judgeGrassType(String coordinates) {
        try {
            // 1. 解析坐标字符串
            List<Point> points = parseCoordinates(coordinates);

            // 2. 数据预处理：删除最后一个闭合点
            // 原因：输入数据通常首尾相同，删除最后一个点避免重复计算
            if (!points.isEmpty()) {
                points.remove(points.size() - 1);
            }

            // 3. 检查点数（移除后至少需要3个点）
            if (points.size() < 3) {
                return 0; // 无法构成多边形
            }

            // 4. 判断形状
            if (isConvexPolygon(points)) {
                return 1; // 凸形草地
            } else {
                return 2; // 异形草地（明显的凹多边形）
            }

        } catch (Exception e) {
            // 解析失败或计算异常
            return 0;
        }
    }

    // 解析坐标字符串
    private List<Point> parseCoordinates(String coordinates) {
        List<Point> points = new ArrayList<>();
        String cleanStr = coordinates.replaceAll("[()\\[\\]{}]", "").trim();
        String[] pointStrings = cleanStr.split(";");

        for (String pointStr : pointStrings) {
            pointStr = pointStr.trim();
            if (pointStr.isEmpty()) continue;
            
            String[] xy = pointStr.split(",");
            if (xy.length != 2) throw new IllegalArgumentException("格式错误");
            
            points.add(new Point(Double.parseDouble(xy[0].trim()), Double.parseDouble(xy[1].trim())));
        }
        return points;
    }

    // 【核心修改】判断多边形是否为凸多边形（带容差）
    private boolean isConvexPolygon(List<Point> points) {
        // 先清理极度接近的点，避免除以零错误
        List<Point> cleanedPoints = cleanDuplicatePoints(points);
        int n = cleanedPoints.size();
        if (n < 3) return false;

        boolean hasPositive = false;
        boolean hasNegative = false;

        for (int i = 0; i < n; i++) {
            Point p0 = cleanedPoints.get(i);
            Point p1 = cleanedPoints.get((i + 1) % n);
            Point p2 = cleanedPoints.get((i + 2) % n);

            // 计算向量 p0->p1 和 p1->p2
            double dx1 = p1.x - p0.x;
            double dy1 = p1.y - p0.y;
            double dx2 = p2.x - p1.x;
            double dy2 = p2.y - p1.y;

            // 计算叉积
            double cross = dx1 * dy2 - dx2 * dy1;

            // 计算边长
            double len1 = Math.sqrt(dx1 * dx1 + dy1 * dy1);
            double len2 = Math.sqrt(dx2 * dx2 + dy2 * dy2);

            // 防止极短边导致的计算错误
            if (len1 < 1e-6 || len2 < 1e-6) continue;

            // 【关键修改】计算归一化的叉积值 (相当于 sinθ)
            // 这代表了弯曲的程度，排除了边长对叉积数值大小的干扰
            double sinTheta = cross / (len1 * len2);

            // 应用容差逻辑：
            // 只有当弯曲程度超过阈值时，才记录方向
            if (sinTheta > ANGLE_TOLERANCE) {
                hasPositive = true; // 明显的左转（凸）
            } else if (sinTheta < -ANGLE_TOLERANCE) {
                hasNegative = true; // 明显的右转（凹）
            }
            // 如果 sinTheta 在 -0.05 到 0.05 之间，认为是直线抖动，忽略不计

            // 如果既有明显的向左转，又有明显的向右转，那就是异形（凹多边形）
            if (hasPositive && hasNegative) {
                return false;
            }
        }
        
        // 如果没有产生冲突的转向，或者是单纯的直线（所有点共线），视为凸形
        return true;
    }

    // 辅助：仅去除重复点，不再过度清理共线点（因为主逻辑已经能处理共线抖动）
    private List<Point> cleanDuplicatePoints(List<Point> points) {
        List<Point> cleaned = new ArrayList<>();
        double tolerance = 1e-6;

        for (Point p : points) {
            if (!cleaned.isEmpty()) {
                Point last = cleaned.get(cleaned.size() - 1);
                if (Math.abs(p.x - last.x) < tolerance && Math.abs(p.y - last.y) < tolerance) {
                    continue; // 跳过重复点
                }
            }
            cleaned.add(p);
        }
        
        // 检查首尾是否因为循环导致重复（虽然主方法删除了最后一个点，为了健壮性再查一次）
        if (cleaned.size() > 1) {
            Point first = cleaned.get(0);
            Point last = cleaned.get(cleaned.size() - 1);
            if (Math.abs(first.x - last.x) < tolerance && Math.abs(first.y - last.y) < tolerance) {
                cleaned.remove(cleaned.size() - 1);
            }
        }
        return cleaned;
    }

    // 点类
    private static class Point {
        double x, y;
        Point(double x, double y) { this.x = x; this.y = y; }
    }
}