package com.fuyuanshen.equipment.utils.c;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * 可靠点阵生成工具 - 终极版
 *
 * @author: 默苍璃
 * @date: 2025-07-15
 */
public class ReliableTextToBitmap {

    public static void main(String[] args) throws IOException {
        String unit = "繁體繁體繁體";
        String department = "A研B发C";
        String name = "12李34四56";

        byte[] unitBytes = textToBitmapBytes(unit);
        for (int i = 0; i < unitBytes.length; i++) {
            //打印byte转十进制
            System.out.printf("0x%02X", unitBytes[i]);
        }
//        System.out.println("单元数据: "+Arrays.toString(unitBytes));
        byte[] deptBytes = textToBitmapBytes(department);
        byte[] nameBytes = textToBitmapBytes(name);

        generateCFile(unitBytes, deptBytes, nameBytes, "display_data.c");

        // 生成预览图片
        generatePreviewImage(unitBytes, "unit_image.png");
        generatePreviewImage(deptBytes, "department_image.png");
        generatePreviewImage(nameBytes, "name_image.png");
    }

    // 专门生成预览图片的方法
    private static void generatePreviewImage(byte[] data, String filename) {
        try {
            BufferedImage image = convertByteArrayToImage(data, 12);
            ImageIO.write(image, "PNG", new File(filename));
            System.out.println("成功生成预览图片: " + filename);
        } catch (IOException e) {
            System.err.println("图片生成失败: " + e.getMessage());
        }
    }

    /**
     * 可靠的字节数组转图像方法
     */
    public static BufferedImage convertByteArrayToImage(byte[] data, int height) {
        if (data == null || data.length == 0) {
            return new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
        }

        // 计算宽度
        int width = (data.length * 8) / height;

        // 创建RGB图像
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);

        // 设置白色背景
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                image.setRGB(x, y, Color.WHITE.getRGB());
            }
        }

        // 直接设置像素点
        int bitIndex = 0;
        for (int i = 0; i < data.length; i++) {
            int value = data[i] & 0xFF;
            for (int bit = 7; bit >= 0; bit--) { // 高位在前
                boolean isBlack = ((value >> bit) & 1) == 1;
                if (isBlack) {
                    int x = bitIndex % width;
                    int y = bitIndex / width;
                    if (y < height) { // 确保不越界
                        image.setRGB(x, y, Color.BLACK.getRGB());
                    }
                }
                bitIndex++;
            }
        }

        return image;
    }

    /**
     * 可靠的点阵生成方法
     */
    public static byte[] textToBitmapBytes(String text) {
        if (text == null || text.isEmpty()) {
            return new byte[0];
        }

        // 1. 创建画布 - 使用RGB类型避免问题
        Font font = new Font("宋体", Font.PLAIN, 12);
        BufferedImage image = createTextImage(text, font);

        // 2. 直接提取点阵数据
        return extractBitmapData(image);
    }

    /**
     * 创建文本图像 - 最可靠的方法
     */
    private static BufferedImage createTextImage(String text, Font font) {
        // 创建临时图像获取字体度量
        BufferedImage tempImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
        Graphics2D tempG = tempImage.createGraphics();
        tempG.setFont(font);
        FontMetrics metrics = tempG.getFontMetrics();

        // 计算文本宽度
        int totalWidth = metrics.stringWidth(text);

        // 宽度对齐到8的倍数
        int width = (int) Math.ceil(totalWidth / 8.0) * 8;
        int height = 12;

        // 创建RGB图像
        BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = image.createGraphics();

        // 设置白色背景
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, width, height);

        // 设置黑色文本
        g.setColor(Color.BLACK);
        g.setFont(font);

        // 关闭抗锯齿 - 确保清晰度
        g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
                RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);

        // 绘制文本 - 精确居中
        int y = (height - metrics.getHeight()) / 2 + metrics.getAscent();
        g.drawString(text, 0, y);

        g.dispose();
        tempG.dispose();

        return image;
    }

    /**
     * 提取点阵数据 - 简单可靠的方法
     */
    private static byte[] extractBitmapData(BufferedImage image) {
        int width = image.getWidth();
        int height = image.getHeight();

        List<Byte> byteList = new ArrayList<>();
        int currentByte = 0;
        int bitCount = 0;

        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                // 获取像素颜色
                Color color = new Color(image.getRGB(x, y));

                // 简单阈值判断 - 灰度小于128为黑色
                int gray = (color.getRed() + color.getGreen() + color.getBlue()) / 3;
                boolean isBlack = gray < 128;

                // 高位优先打包
                currentByte = (currentByte << 1) | (isBlack ? 1 : 0);
                bitCount++;

                if (bitCount == 8) {
                    byteList.add((byte) currentByte);
                    currentByte = 0;
                    bitCount = 0;
                }
            }
        }

        // 处理最后不满8位的部分
        if (bitCount > 0) {
            currentByte <<= (8 - bitCount);
            byteList.add((byte) currentByte);
        }

        return byteListToArray(byteList);
    }

    private static byte[] byteListToArray(List<Byte> byteList) {
        byte[] result = new byte[byteList.size()];
        for (int i = 0; i < byteList.size(); i++) {
            result[i] = byteList.get(i);
        }
        return result;
    }

    public static void generateCFile(byte[] unit, byte[] department, byte[] name, String filename) throws IOException {
        try (FileWriter writer = new FileWriter(filename)) {
            writer.write("/**\n");
            writer.write(" * 点阵显示数据 - 可靠生成\n");
            writer.write(" * 宽度计算公式: width = (数组长度 * 8) / 12\n");
            writer.write(" */\n\n");
            writer.write("#include <stdint.h>\n\n");

            // 单位数据
            writer.write(String.format("// 单位: %d 字节, 宽度: %d 像素\n",
                    unit.length, (unit.length * 8) / 12));
            writer.write("const uint8_t unit[] = {\n    ");
            writeByteArray(writer, unit);
            writer.write("\n};\n\n");

            // 部门数据
            writer.write(String.format("// 部门: %d 字节, 宽度: %d 像素\n",
                    department.length, (department.length * 8) / 12));
            writer.write("const uint8_t department[] = {\n    ");
            writeByteArray(writer, department);
            writer.write("\n};\n\n");

            // 姓名数据
            writer.write(String.format("// 姓名: %d 字节, 宽度: %d 像素\n",
                    name.length, (name.length * 8) / 12));
            writer.write("const uint8_t name[] = {\n    ");
            writeByteArray(writer, name);
            writer.write("\n};\n");
        }
    }

    private static void writeByteArray(FileWriter writer, byte[] data) throws IOException {
        for (int i = 0; i < data.length; i++) {
            int value = data[i] & 0xFF;
            writer.write(String.format("0x%02X", value));

            if (i < data.length - 1) {
                writer.write(", ");
                if ((i + 1) % 12 == 0) writer.write("\n    ");
            }
        }
    }
}