#include <glut.h>
#include <iostream>
#include <vector>
#include <algorithm>

// 定义点结构体，用于表示像素或顶点位置
struct Point {
    int x, y;
    Point(int _x, int _y) : x(_x), y(_y) {}
};

// 矩阵乘法函数
std::vector<Point> matrixMultiply(const std::vector<Point>& points, const std::vector<std::vector<float>>& matrix) {
    std::vector<Point> transformedPoints;
    for (const auto& p : points) {
        float newX = matrix[0][0] * p.x + matrix[0][1] * p.y + matrix[0][2];
        float newY = matrix[1][0] * p.x + matrix[1][1] * p.y + matrix[1][2];
        transformedPoints.emplace_back(static_cast<int>(newX), static_cast<int>(newY));
    }
    return transformedPoints;
}

// 旋转变换矩阵
std::vector<std::vector<float>> rotationMatrix(float angle) {
    float rad = angle * 3.1415926 / 180.0;
    return {
        {std::cos(rad), -std::sin(rad), 0},
        {std::sin(rad), std::cos(rad), 0},
        {0, 0, 1}
    };
}

// 缩放变换矩阵
std::vector<std::vector<float>> scalingMatrix(float sx, float sy) {
    return {
        {sx, 0, 0},
        {0, sy, 0},
        {0, 0, 1}
    };
}

// 平移变换矩阵
std::vector<std::vector<float>> translationMatrix(float tx, float ty) {
    return {
        {1, 0, tx},
        {0, 1, ty},
        {0, 0, 1}
    };
}

//中点画线算法
// 仅用于绘制轮廓线，采用整数计算的方式逼近直线
void midPointLine(int x1, int y1, int x2, int y2, std::vector<Point>& points) {
    int dx = std::abs(x2 - x1);
    int dy = std::abs(y2 - y1);
    int sx = (x1 < x2) ? 1 : -1;   // 判断 x 方向前进或后退
    int sy = (y1 < y2) ? 1 : -1;   // 判断 y 方向前进或后退
    int err = dx - dy;             // 初始误差值

    while (true) {
        points.emplace_back(x1, y1);   // 添加当前像素
        if (x1 == x2 && y1 == y2) break;   // 到达终点则停止
        int e2 = 2 * err;
        if (e2 > -dy) { err -= dy; x1 += sx; }
        if (e2 < dx) { err += dx; y1 += sy; }
    }
}

// 外部调用的封装函数（简化调用）
void drawLine(int x1, int y1, int x2, int y2, std::vector<Point>& points) {
    midPointLine(x1, y1, x2, y2, points);
}

// 扫描线填充算法
// 用于填充封闭多边形的内部区域
void fillPolygon(const std::vector<Point>& polygon, std::vector<Point>& filledPoints) {
    // 获取多边形的 y 范围（扫描线只在这个范围扫描）
    int minY = polygon[0].y, maxY = polygon[0].y;
    for (const auto& p : polygon) {
        minY = std::min(minY, p.y);
        maxY = std::max(maxY, p.y);
    }

    // 扫描每一行
    for (int y = minY; y <= maxY; y++) {
        std::vector<int> intersections;  // 当前扫描线与多边形的交点集合

        // 遍历多边形每条边，找出和当前扫描线有交点的边
        for (size_t i = 0; i < polygon.size(); i++) {
            const auto& p1 = polygon[i];
            const auto& p2 = polygon[(i + 1) % polygon.size()];

            // 判断当前边是否跨过扫描线
            if ((p1.y <= y && p2.y > y) || (p2.y <= y && p1.y > y)) {
                // 计算交点 x 坐标（线性插值）
                int x = p1.x + (y - p1.y) * (p2.x - p1.x) / (p2.y - p1.y);
                intersections.push_back(x);
            }
        }

        // 将交点排序，然后成对连接，填充像素
        std::sort(intersections.begin(), intersections.end());
        for (size_t i = 0; i < intersections.size(); i += 2) {
            for (int x = intersections[i]; x < intersections[i + 1]; x++) {
                filledPoints.emplace_back(x, y);
            }
        }
    }
}

// 三点水左边三个点，每个点是一个三角形
std::vector<Point> threeDotsVertices[] = {
    {{60, 360}, {80, 390}, {100, 350}},         // 上
    {{70, 290}, {95, 320}, {110, 280}},         // 中
    {{85, 220}, {110, 250}, {125, 210}}         // 下
};

// 右半部分汉字结构（如“浩”的右边）各个笔画的顶点坐标
std::vector<Point> leftStrokeVertices = {
    {180, 420}, {210, 430},
    {185, 380}, {155, 370}
};

std::vector<Point> upperHorizontalVertices = {  // 上横
    {220, 420}, {360, 420},
    {360, 400}, {220, 400}
};

std::vector<Point> lowerHorizontalVertices = {  // 下横
    {210, 330}, {370, 330},
    {370, 310}, {210, 310}
};

std::vector<Point> verticalLineVertices = {     // 中竖
    {290, 450}, {310, 450},
    {310, 310}, {290, 310}
};

std::vector<Point> mouthOuterVertices = {       // 外口（梯形）
    {220, 270}, {360, 270},
    {340, 190}, {240, 190}
};

std::vector<Point> mouthInnerVertices = {       // 内口（红色填充部分）
    {250, 250}, {330, 250},
    {315, 205}, {265, 205}
};

//  绘制所有轮廓线（绿色）
void drawOutlines(const std::vector<Point>& vertices, std::vector<Point>& outlinePoints) {
    for (size_t i = 0; i < vertices.size(); i++) {
        drawLine(vertices[i].x, vertices[i].y, vertices[(i + 1) % vertices.size()].x, vertices[(i + 1) % vertices.size()].y, outlinePoints);
    }
}

// 填充所有封闭区域（蓝色为主）
void fillAllParts(const std::vector<Point>& vertices, std::vector<Point>& filledPoints) {
    fillPolygon(vertices, filledPoints);
}

//显示函数（OpenGL 回调）
void display() {
    glClear(GL_COLOR_BUFFER_BIT);  // 清除屏幕

    // 计算图形中心
    int minX = 9999, minY = 9999, maxX = 0, maxY = 0;
    std::vector<std::vector<Point>> allVertices = {
        threeDotsVertices[0], threeDotsVertices[1], threeDotsVertices[2],
        leftStrokeVertices, upperHorizontalVertices, lowerHorizontalVertices,
        verticalLineVertices, mouthOuterVertices, mouthInnerVertices
    };
    for (const auto& vertices : allVertices) {
        for (const auto& p : vertices) {
            minX = std::min(minX, p.x);
            minY = std::min(minY, p.y);
            maxX = std::max(maxX, p.x);
            maxY = std::max(maxY, p.y);
        }
    }
    int centerX = (minX + maxX) / 2;
    int centerY = (minY + maxY) / 2;

    // 视口 1：旋转并向右平移
    glViewport(0, 0, 900, 600);
    auto translateToCenter = translationMatrix(-centerX, -centerY);
    auto rotMatrix = rotationMatrix(45);
    auto translateBack = translationMatrix(centerX + 50, centerY); // 向右平移 50 个单位
    std::vector<std::vector<float>> combinedMatrix = {
        {translateBack[0][0] * (rotMatrix[0][0] * translateToCenter[0][0] + rotMatrix[0][1] * translateToCenter[1][0]) + translateBack[0][1] * (rotMatrix[1][0] * translateToCenter[0][0] + rotMatrix[1][1] * translateToCenter[1][0]),
         translateBack[0][0] * (rotMatrix[0][0] * translateToCenter[0][1] + rotMatrix[0][1] * translateToCenter[1][1]) + translateBack[0][1] * (rotMatrix[1][0] * translateToCenter[0][1] + rotMatrix[1][1] * translateToCenter[1][1]),
         translateBack[0][0] * (rotMatrix[0][0] * translateToCenter[0][2] + rotMatrix[0][1] * translateToCenter[1][2] + rotMatrix[0][2]) + translateBack[0][1] * (rotMatrix[1][0] * translateToCenter[0][2] + rotMatrix[1][1] * translateToCenter[1][2] + rotMatrix[1][2]) + translateBack[0][2]},
        {translateBack[1][0] * (rotMatrix[0][0] * translateToCenter[0][0] + rotMatrix[0][1] * translateToCenter[1][0]) + translateBack[1][1] * (rotMatrix[1][0] * translateToCenter[0][0] + rotMatrix[1][1] * translateToCenter[1][0]),
         translateBack[1][0] * (rotMatrix[0][0] * translateToCenter[0][1] + rotMatrix[0][1] * translateToCenter[1][1]) + translateBack[1][1] * (rotMatrix[1][0] * translateToCenter[0][1] + rotMatrix[1][1] * translateToCenter[1][1]),
         translateBack[1][0] * (rotMatrix[0][0] * translateToCenter[0][2] + rotMatrix[0][1] * translateToCenter[1][2] + rotMatrix[0][2]) + translateBack[1][1] * (rotMatrix[1][0] * translateToCenter[0][2] + rotMatrix[1][1] * translateToCenter[1][2] + rotMatrix[1][2]) + translateBack[1][2]},
        {0, 0, 1}
    };

    std::vector<Point> outlinePoints1;
    std::vector<Point> filledPoints1;
    for (const auto& vertices : allVertices) {
        auto transformedVertices = matrixMultiply(vertices, combinedMatrix);
        drawOutlines(transformedVertices, outlinePoints1);
        fillAllParts(transformedVertices, filledPoints1);
    }

    // 绘制轮廓线（绿色）
    glColor3f(0.0, 1.0, 0.0);
    glBegin(GL_POINTS);
    for (const auto& p : outlinePoints1) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 绘制填充区域（蓝色）
    glColor3f(0.0, 0.0, 1.0);
    glBegin(GL_POINTS);
    for (const auto& p : filledPoints1) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 单独填充 mouthInnerVertices（红色，表示空心内部）
    glColor3f(1.0, 0.0, 0.0);
    std::vector<Point> innerMouthFill1;
    auto transformedInnerMouth = matrixMultiply(mouthInnerVertices, combinedMatrix);
    fillPolygon(transformedInnerMouth, innerMouthFill1);
    glBegin(GL_POINTS);
    for (const auto& p : innerMouthFill1) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 视口 2：缩小
    glViewport(300, 0, 300, 600);
    auto scaleMatrix = scalingMatrix(0.5, 0.5);
    std::vector<Point> outlinePoints2;
    std::vector<Point> filledPoints2;
    for (const auto& vertices : allVertices) {
        auto transformedVertices = matrixMultiply(vertices, scaleMatrix);
        drawOutlines(transformedVertices, outlinePoints2);
        fillAllParts(transformedVertices, filledPoints2);
    }

    // 绘制轮廓线（绿色）
    glColor3f(0.0, 1.0, 0.0);
    glBegin(GL_POINTS);
    for (const auto& p : outlinePoints2) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 绘制填充区域（蓝色）
    glColor3f(0.0, 0.0, 1.0);
    glBegin(GL_POINTS);
    for (const auto& p : filledPoints2) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 单独填充 mouthInnerVertices（红色，表示空心内部）
    glColor3f(1.0, 0.0, 0.0);
    std::vector<Point> innerMouthFill2;
    auto transformedInnerMouth2 = matrixMultiply(mouthInnerVertices, scaleMatrix);
    fillPolygon(transformedInnerMouth2, innerMouthFill2);
    glBegin(GL_POINTS);
    for (const auto& p : innerMouthFill2) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 视口 3：平移
    glViewport(600, 0, 300, 600);
    auto transMatrix3 = translationMatrix(100, 50);
    std::vector<Point> outlinePoints3;
    std::vector<Point> filledPoints3;
    for (const auto& vertices : allVertices) {
        auto transformedVertices = matrixMultiply(vertices, transMatrix3);
        drawOutlines(transformedVertices, outlinePoints3);
        fillAllParts(transformedVertices, filledPoints3);
    }

    // 绘制轮廓线（绿色）
    glColor3f(0.0, 1.0, 0.0);
    glBegin(GL_POINTS);
    for (const auto& p : outlinePoints3) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 绘制填充区域（蓝色）
    glColor3f(0.0, 0.0, 1.0);
    glBegin(GL_POINTS);
    for (const auto& p : filledPoints3) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    // 单独填充 mouthInnerVertices（红色，表示空心内部）
    glColor3f(1.0, 0.0, 0.0);
    std::vector<Point> innerMouthFill3;
    auto transformedInnerMouth3 = matrixMultiply(mouthInnerVertices, transMatrix3);
    fillPolygon(transformedInnerMouth3, innerMouthFill3);
    glBegin(GL_POINTS);
    for (const auto& p : innerMouthFill3) {
        glVertex2i(p.x, p.y);
    }
    glEnd();

    glFlush();  // 强制刷新 OpenGL 绘图命令
}

//OpenGL 初始化函数
void init() {
    glClearColor(0.0, 0.0, 0.0, 0.0);  // 背景色为黑色
    gluOrtho2D(0, 900, 0, 600);       // 设置 2D 正交投影（左下为原点）
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);                            // 初始化 GLUT
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);      // 单缓冲 + RGB 模式
    glutInitWindowSize(900, 600);                     // 设置窗口大小
    glutCreateWindow("Hollow and Filled Hao");        // 创建窗口并命名
    init();                                           // 初始化绘图参数
    glutDisplayFunc(display);                         // 注册显示回调函数
    glutMainLoop();                                   // 进入主循环，等待事件
    return 0;
}