import * as THREE from "three";
import { TextGeometry } from "three/examples/jsm/geometries/TextGeometry.js";
import { OrbitControls } from "three/examples/jsm/controls/OrbitControls.js";
import { TTFLoader } from "three/examples/jsm/loaders/TTFLoader.js";
// import { SSAARenderPass } from "three/examples/jsm/postprocessing/SSAARenderPass.js";
// import { UnrealBloomPass } from "three/examples/jsm/postprocessing/UnrealBloomPass.js";
// import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
// import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js';
// import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
import {
    addTriangleFacingCamera,
    getBSplinePolyline, getBulgeCurvePoints,
    mtextContentAndFormattingToTextAndStyle
} from "./drawUtils";
// @ts-ignore
import { parseDxfMTextContent } from "@dxfom/mtext";
import { Font } from "three/examples/jsm/loaders/FontLoader.js";
import { PickHelper } from "./pickHelper";
import { DrawRect } from "./drawRect";
import log from '@/utils/log/Logger';

let signal, middleObject;
let scene, helpScene, camera, renderer, inputElement, font, data;

// 渲染辉光图层
// let composer, finalComposer;
const BLOOM_SCENE = 10;
const bloomLayer = new THREE.Layers();
bloomLayer.set(BLOOM_SCENE);
// const DarkMaterial = new THREE.MeshBasicMaterial({ color: 'black' });
// const materials = {};

let modules: any = {};

// TODO 当前解析模式会存在 data.blocks 中还有实体但未匹配解析的情况；
// 记录已经解析的 data.blocks,data.entities遍历完成后处理
let parsedBlocks: string[] = [];
// 渲染配置项 && 对比度颜色实体集合
let options = {
    bgColor: 0x000000,
    contrastColor: 0xffffff,
    fontUrl:''
}, contrastEntity: any = [];

// canvas默认宽高
export const state = {
    width: 500,
    height: 500,
};

/**
 * 离屏canvas和普通canvas共用的绘制图纸方法
 * 优先级：offScreenCanvas > canvas
 */
export function main(d) {
    const { canvas, onComplete } = d;
    signal = d.signal;
    middleObject = d.middleObject;
    state.width = canvas.width;
    state.height = canvas.height;
    inputElement = d.inputElement;
    data = d.data;
    // cad配置项
    options = Object.assign(options, d.options);
    options.bgColor = Number(options.bgColor);
    options.contrastColor = options.bgColor === 0x000000 ? 0xffffff : 0x000000;

    createLineTypeShaders();

    renderer = new THREE.WebGLRenderer({
        canvas,
        powerPreference: "high-performance",
        depth: false,
        antialias: true,
    });
    // 第三个参数false代表不更新canvas dom style
    renderer.setSize(canvas.width, canvas.height, false);
    renderer.setClearColor(options.bgColor, 1);
    renderer.toneMapping = THREE.ReinhardToneMapping;
    // renderer.autoClear = false;

    const loader = new TTFLoader();
    loader.loadAsync(options.fontUrl).then(function (response) {
        font = new Font(response);

        init();

        // OrbitControls mousemove事件中未调用chang事件，所以需要一直渲染
        renderLoop();

        // 添加灯光
        scene.add(new THREE.AmbientLight(0xffffff, 1));

        // 后期通道
        // initComposer();

        const controls = new OrbitControls(camera, inputElement);
        controls.target.x = camera.position.x;
        controls.target.y = camera.position.y;
        controls.target.z = 0;
        controls.mouseButtons = { LEFT: THREE.MOUSE.PAN, MIDDLE: THREE.MOUSE.DOLLY, RIGHT: THREE.MOUSE.ROTATE };
        controls.enableRotate = false;
        controls.update();

        // 注册模块
        modules.drawRect = new DrawRect(inputElement, helpScene, camera, signal, middleObject);
        modules.drawRect.setControls(controls);

        const pickPosition = new THREE.Vector2(0, 0);
        modules.pickHelper = new PickHelper(scene, camera, BLOOM_SCENE);
        clearPickPosition();

        function getCanvasRelativePosition(event) {
            const rect = inputElement.getBoundingClientRect();
            return {
                x: event.clientX - rect.left,
                y: event.clientY - rect.top,
            };
        }

        function setPickPosition(event) {
            const pos = getCanvasRelativePosition(event);
            pickPosition.x = (pos.x / state.width) * 2 - 1;
            pickPosition.y = (pos.y / state.height) * - 2 + 1;

            modules.pickHelper.pick(pickPosition);
        }

        function clearPickPosition() {
            //不像鼠标总是有一个位置，如果用户停止触摸屏幕，我们想要停止。现在我们只取一个不太可能取到的值
            pickPosition.x = - 100000;
            pickPosition.y = - 100000;
        }

        inputElement.addEventListener('mousemove', setPickPosition);
        inputElement.addEventListener('mouseout', clearPickPosition);
        inputElement.addEventListener('mouseleave', clearPickPosition);

        inputElement.addEventListener('touchstart', (event) => {
            // 防止窗口滚动
            event.preventDefault();
            setPickPosition(event.touches[0]);
        }, { passive: false });
        inputElement.addEventListener('touchmove', (event) => {
            setPickPosition(event.touches[0]);
        });
        inputElement.addEventListener('touchend', clearPickPosition);

        // 加载完毕
        onComplete && onComplete();

        font = undefined;
        data = undefined;

        resize({ width: inputElement.width, height: inputElement.height });
    });
}

function createLineTypeShaders() {
    let ltype, type;
    if (!data.tables || !data.tables.lineType) return;
    const ltypes = data.tables.lineType.lineTypes;

    for (type in ltypes) {
        ltype = ltypes[type];
        if (!ltype.pattern) continue;
        ltype.material = createDashedLineShader(ltype.pattern);
    }
}

function createDashedLineShader(pattern) {
    let dashedLineShader: any = {},
        totalLength = 0.0;

    for (let i = 0; i < pattern.length; i++) {
        totalLength += Math.abs(pattern[i]);
    }

    dashedLineShader.uniforms = THREE.UniformsUtils.merge([
        THREE.UniformsLib['common'],
        THREE.UniformsLib['fog'],

        {
            // @ts-ignore
            'pattern': { type: 'fv1', value: pattern },
            // @ts-ignore
            'patternLength': { type: 'f', value: totalLength }
        }
    ]);

    dashedLineShader.vertexShader = [
        'attribute float lineDistance;',

        'varying float vLineDistance;',

        THREE.ShaderChunk['color_pars_vertex'],

        'void main() {',

        THREE.ShaderChunk['color_vertex'],

        'vLineDistance = lineDistance;',

        'gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );',

        '}'
    ].join('\n');

    dashedLineShader.fragmentShader = [
        'uniform vec3 diffuse;',
        'uniform float opacity;',

        'uniform float pattern[' + pattern.length + '];',
        'uniform float patternLength;',

        'varying float vLineDistance;',

        THREE.ShaderChunk['color_pars_fragment'],
        THREE.ShaderChunk['fog_pars_fragment'],

        'void main() {',

        'float pos = mod(vLineDistance, patternLength);',

        'for ( int i = 0; i < ' + pattern.length + '; i++ ) {',
        'pos = pos - abs(pattern[i]);',
        'if( pos < 0.0 ) {',
        'if( pattern[i] > 0.0 ) {',
        'gl_FragColor = vec4(1.0, 0.0, 0.0, opacity );',
        'break;',
        '}',
        'discard;',
        '}',

        '}',

        THREE.ShaderChunk['color_fragment'],
        THREE.ShaderChunk['fog_fragment'],

        '}'
    ].join('\n');

    return dashedLineShader;
}

function init() {
    scene = new THREE.Scene();
    scene.background = new THREE.Color(options.bgColor);
    helpScene = new THREE.Scene();

    const layersGroupMap: Map<string, THREE.Group> = new Map();
    // 使用layers生成group
    for (let layerName in data.tables.layer.layers) {
        const layer = data.tables.layer.layers[layerName];
        const group = new THREE.Group();
        group.name = layerName;
        group.visible = layer.visible;

        layersGroupMap.set(layerName, group);
        scene.add(group);
    }

    // 通过dxf数据创建场景
    let entity, obj;
    // 生成所有实体
    for (let i = 0; i < data.entities?.length; i++) {
        entity = data.entities[i];

        obj = drawEntity(entity);

        if (obj) {
            if (layersGroupMap.has(entity.layer)) {
                const parent = layersGroupMap.get(entity.layer) || scene;
                parent.add(obj);
                obj.name = `${entity.type}-${entity.handle || 'noHandle'}-${parent.children.length}`
            } else {
                scene.add(obj);
                obj.name = `${entity.type}-${entity.handle || 'noHandle'}-${scene.children.length}`
            }
        }
        obj = null;
    }

    // 2023-9-6:遍历所有剩下的未遍历的块，找出其中 INSERT/DIMENSION 类型的实体，进行解析.(非此类型就算解析位置也不正确)
    // TODO 待删除
    for (let blockName in data.blocks) {
        const block = data.blocks[blockName];

        if (parsedBlocks.includes(blockName) || !block.position || !block.entities) continue;

        for (let j = 0; j < block.entities.length; j++) {
            entity = block.entities[j];
            if (entity.type == "INSERT" || entity.type == "DIMENSION") {
                // TODO 容易栈溢出
                // obj = this.drawEntity(entity);
                //
                // if (obj) {
                //     const bbox = new THREE.Box3().setFromObject(obj);
                //     if (isFinite(bbox.min.x) && (dims.min.x > bbox.min.x)) dims.min.x = bbox.min.x;
                //     if (isFinite(bbox.min.y) && (dims.min.y > bbox.min.y)) dims.min.y = bbox.min.y;
                //     if (isFinite(bbox.min.z) && (dims.min.z > bbox.min.z)) dims.min.z = bbox.min.z;
                //     if (isFinite(bbox.max.x) && (dims.max.x < bbox.max.x)) dims.max.x = bbox.max.x;
                //     if (isFinite(bbox.max.y) && (dims.max.y < bbox.max.y)) dims.max.y = bbox.max.y;
                //     if (isFinite(bbox.max.z) && (dims.max.z < bbox.max.z)) dims.max.z = bbox.max.z;
                //     this.scene.add(obj);
                // }
                // obj = null;
            }
        }
    }

    const aspectRatio = state.width / state.height;
    const dims = new THREE.Box3().setFromObject(scene);
    const upperRightCorner = { x: dims.max.x, y: dims.max.y };
    const lowerLeftCorner = { x: dims.min.x, y: dims.min.y };
    //const lowerLeftCorner = data.header.$EXTMIN; // X、Y 和 Z 图形范围左下角（在 WCS 中）
    //const upperRightCorner = data.header.$EXTMAX; // X、Y 和 Z 图形范围右上角（在 WCS 中）

    // 找出当前的视口范围
    let vp_width = upperRightCorner.x - lowerLeftCorner.x;
    let vp_height = upperRightCorner.y - lowerLeftCorner.y;
    let center = {
        x: vp_width / 2 + lowerLeftCorner.x,
        y: vp_height / 2 + lowerLeftCorner.y
    };
    //let center = data.tables.viewPort.viewPorts[0].ucsOrigin;

    // 将所有对象放入当前的查看器中
    const extentsAspectRatio = Math.abs(vp_width / vp_height);
    if (aspectRatio > extentsAspectRatio) {
        vp_width = vp_height * aspectRatio;
    } else {
        vp_height = vp_width / aspectRatio;
    }

    const viewPort = {
        bottom: -vp_height / 2,
        left: -vp_width / 2,
        top: vp_height / 2,
        right: vp_width / 2,
        center: {
            x: center.x,
            y: center.y
        }
    };

    camera = new THREE.OrthographicCamera(viewPort.left, viewPort.right, viewPort.top, viewPort.bottom, 1, 19);
    camera.position.z = 1;
    camera.position.x = viewPort.center.x;
    camera.position.y = viewPort.center.y;
    camera.userData.viewPort = viewPort;

    // 销毁中间变量
    layersGroupMap.clear();
}

// function initComposer() {
//     const pixelRatio = renderer.getPixelRatio();
//
//     composer = new EffectComposer(renderer);
//     composer.renderToScreen = false;
//     composer.setPixelRatio(pixelRatio)
//
//     let ssaaRenderPass = new SSAARenderPass(scene, camera);
//     ssaaRenderPass.unbiased = false;
//     ssaaRenderPass.sampleLevel = 2;
//     composer.addPass(ssaaRenderPass);
//
//     const bloomPass = new UnrealBloomPass(
//         //参数一：泛光覆盖场景大小，二维向量类型
//         new THREE.Vector2(inputElement.width, inputElement.height),
//         //参数二：bloomStrength 泛光强度，值越大明亮的区域越亮，较暗区域变亮的范围越广
//         1.5,
//         //参数三：bloomRadius 泛光散发半径
//         0,
//         //参数四：bloomThreshold 泛光的光照强度阈值，如果照在物体上的光照强度大于该值就会产生泛光
//         0
//     );
//     composer.addPass(bloomPass);
//
//     const mixPass = new ShaderPass(
//         new THREE.ShaderMaterial({
//             uniforms: {
//                 baseTexture: { value: null },
//                 bloomTexture: { value: composer.renderTarget2.texture }
//             },
//             vertexShader: `
//             varying vec2 vUv;
//                 void main() {
//                 vUv = uv;
//                 gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
//             }
// `,
//             fragmentShader: `
//             uniform sampler2D baseTexture;
//             uniform sampler2D bloomTexture;
//             varying vec2 vUv;
//             void main() {
//                 gl_FragColor = ( texture2D( baseTexture, vUv ) + vec4( 1.0 ) * texture2D( bloomTexture, vUv ) );
//             }`,
//             defines: {}
//         }), 'baseTexture'
//     );
//     mixPass.needsSwap = true;
//
//     const outputPass = new OutputPass();
//
//     finalComposer = new EffectComposer(renderer);
//     finalComposer.addPass(ssaaRenderPass);
//     finalComposer.addPass(mixPass);
//     finalComposer.addPass(outputPass);
// }

// 图元选中
export function select({ modelOrName }) {
    let model = modelOrName;
    if (typeof modelOrName === 'string') {
        model = scene.getObjectByProperty('name', modelOrName);
    }

    if (model) {
        modules.pickHelper.select(model);
    }
}

/** ------------------------------------------实体解析部分-------------------------------------------------------- **/
function getColor(entity) {
    let color = options.contrastColor;//默认高对比度颜色
    if (entity.color !== undefined) color = entity.color;
    else if (data.tables && data.tables.layer && data.tables.layer.layers[entity.layer])
        color = data.tables.layer.layers[entity.layer].color;

    // 因为 scene.background = new THREE.Color(options.bgColor)，所以黑色显示时改为白色
    if (color == null || color === 0 || color === options.bgColor) {
        color = options.contrastColor;
    }
    return color;
}

function drawEntity(entity) {
    // 2023-9-6: 仅解析模型空间的实体
    if (entity.inPaperSpace) return null;

    let mesh;
    switch (entity.type) {
        case 'CIRCLE':
        case 'ARC':
            mesh = drawArc(entity);
            break;
        case 'LWPOLYLINE':
        case 'LINE':
        case 'POLYLINE':
            mesh = drawLine(entity);
            break;
        case 'TEXT':
            mesh = drawText(entity);
            break;
        case 'ATTDEF':
            mesh = drawAttdef(entity);
            break;
        case 'ATTRIB':
            mesh = drawAttrib(entity);
            break;
        case 'SOLID':
            mesh = drawSolid(entity);
            break;
        case 'POINT':
            mesh = drawPoint(entity);
            break;
        case 'INSERT':
            mesh = drawBlock(entity);
            break;
        case 'SPLINE':
            mesh = drawSpline(entity);
            break;
        case 'MTEXT':
            // console.log("实体类型 MTEXT:", entity);
            mesh = drawMtext(entity);
            break;
        case 'ELLIPSE':
            mesh = drawEllipse(entity);
            break;
        case "HATCH":
            mesh = drawHatch(entity);
            break;
        case 'DIMENSION':
            const dimTypeEnum = entity.dimensionType & 7;
            if (dimTypeEnum === 0) {
                mesh = drawDimension(entity);
            } else {
                //console.log("不支持的维度类型: " + dimTypeEnum);
            }
            break;
        default:
            log.warn("不支持的实体类型: " + entity.type);
            break;
    }

    if (mesh?.material && mesh.material?.color.getHex() === options.contrastColor) {
        contrastEntity.push(mesh)
    }

    return mesh;
}

function drawArc(entity) {
    let startAngle: number, endAngle: number;
    if (entity.type === 'CIRCLE') {
        startAngle = entity.startAngle || 0;
        endAngle = startAngle + 2 * Math.PI;
    } else {
        startAngle = entity.startAngle;
        endAngle = entity.endAngle;
    }

    //@ts-ignore
    const curve = new THREE.ArcCurve(
        0, 0,
        entity.radius,
        startAngle,
        endAngle);

    const points = curve.getPoints(32);
    const geometry = new THREE.BufferGeometry().setFromPoints(points);

    const material = new THREE.LineBasicMaterial({ color: getColor(entity) });

    const arc = new THREE.Line(geometry, material);
    arc.position.x = entity.center.x;
    arc.position.y = entity.center.y;
    arc.position.z = entity.center.z;

    return arc;
}

function drawLine(entity) {
    let points: THREE.Vector3[] = [];
    let color = getColor(entity);
    let material, lineType, vertex, startPoint, endPoint,
        bulge, i, line;

    if (!entity.vertices) return; //console.log('缺少顶点的实体.');

    // 创建几何
    for (i = 0; i < entity.vertices.length; i++) {
        if (entity.vertices[i].bulge) {
            bulge = entity.vertices[i].bulge;
            startPoint = entity.vertices[i];
            endPoint = i + 1 < entity.vertices.length ? entity.vertices[i + 1] : points[0];

            let bulgePoints = getBulgeCurvePoints(startPoint, endPoint, bulge);

            points.push.apply(points, bulgePoints);
        } else {
            vertex = entity.vertices[i];
            points.push(new THREE.Vector3(vertex.x, vertex.y, 0));
        }

    }
    if (entity.shape) points.push(points[0]);


    // 设置材质
    if (entity.lineType) {
        lineType = data.tables.lineType.lineTypes[entity.lineType];
    }

    if (lineType && lineType.pattern && lineType.pattern.length !== 0) {
        material = new THREE.LineDashedMaterial({ color: color, gapSize: 4, dashSize: 4 });
    } else {
        material = new THREE.LineBasicMaterial({ linewidth: 1, color: color });
    }

    const geometry = new THREE.BufferGeometry().setFromPoints(points);

    line = new THREE.Line(geometry, material);
    return line;
}

function drawText(entity) {
    let geometry, material, text;

    if (!font)
        return log.warn('文本不支持没有Three.js字体加载的THREE.FontLoader!');

    if (entity.text == null || entity.text == "") return null;

    if (entity.textHeight == null || entity.textHeight == 0) return null;

    // 当前使用的字体略宽，需要缩小一点
    // xScale: 相对 X 比例因子 — 宽度
    let fontSize = entity.xScale ? entity.xScale * entity.textHeight * 0.73 : entity.textHeight * 0.5;
    geometry = new TextGeometry(entity.text, { font: font, depth: 0, size: fontSize || 100 });

    if (entity.rotation) {
        const zRotation = entity.rotation * Math.PI / 180;
        geometry.rotateZ(zRotation);
    }

    material = new THREE.MeshBasicMaterial({ color: getColor(entity) });

    text = new THREE.Mesh(geometry, material);
    text.position.x = entity.startPoint.x;
    text.position.y = entity.startPoint.y;
    text.position.z = entity.startPoint.z;

    return text;
}

function drawMtext(entity) {
    const color = getColor(entity);

    const textAndControlChars = parseDxfMTextContent(entity.text);

    //Note: 目前只支持应用于所有mtext文本的单一格式
    const content = mtextContentAndFormattingToTextAndStyle(textAndControlChars, entity, color);

    /* 单行文本渲染模式 */
    if (!font)
        return log.warn('文本不支持没有Three.js字体加载的THREE.FontLoader!');

    if (content.text == null || content.text == "") return null;
    if (content.style.textHeight == null || content.style.textHeight == 0) return null;

    const geometry = new TextGeometry(content.text, { font: font, depth: 0, size: content.style.textHeight || 100 });
    if (entity.rotation) {
        const zRotation = entity.rotation * Math.PI / 180;
        geometry.rotateZ(zRotation);
    }
    if (entity.directionVector) {
        const dv = entity.directionVector;
        geometry.rotateZ(new THREE.Vector3(1, 0, 0).angleTo(new THREE.Vector3(dv.x, dv.y, dv.z)));
    }
    const material = new THREE.MeshBasicMaterial({ color });
    const text = new THREE.Mesh(geometry, material);
    text.position.x = entity.position.x;
    text.position.y = entity.position.y;
    text.position.z = entity.position.z;

    return text;


    /* TODO:多行文本渲染,拉近不显示 */
    /*const txt = createTextForScene(content.text, content.style, entity, color,options.fontUrl);
    if (!txt) return null;

    console.log("MText txt:", txt);

    // const group = new THREE.Object3D();
    // group.add(txt);
    return txt;*/
}

// @ts-ignore
function drawAttdef(entity) {
    //console.log("drawAttdef:", entity);
}

// @ts-ignore
function drawAttrib(entity) {
    //console.log("drawAttrib:", entity);
}

function drawSolid(entity) {
    let material, verts,
        geometry = new THREE.BufferGeometry();

    const points = entity.points;
    // verts = geometry.vertices;
    verts = [];
    addTriangleFacingCamera(verts, points[0], points[1], points[2]);
    addTriangleFacingCamera(verts, points[1], points[2], points[3]);

    material = new THREE.MeshBasicMaterial({ color: getColor(entity) });
    geometry.setFromPoints(verts);

    return new THREE.Mesh(geometry, material);
}

function drawPoint(entity) {
    let geometry, material;

    geometry = new THREE.BufferGeometry();

    geometry.setAttribute('position', new THREE.Float32BufferAttribute([entity.position.x, entity.position.y, entity.position.z], 3));

    const color = getColor(entity);

    material = new THREE.PointsMaterial({ size: 0.1, color: new THREE.Color(color) });
    return new THREE.Points(geometry, material);
    // this.scene.add(point);
}

function drawBlock(entity) {
    if (!data.blocks) return;

    let block = data.blocks[entity.name];

    if (!block) return null;

    // 解析过的就存储起来，不再重复解析
    parsedBlocks.push(entity.name);

    if (!block.entities) return null;

    const group = new THREE.Group();

    if (entity.xScale) group.scale.x = entity.xScale;
    if (entity.yScale) group.scale.y = entity.yScale;

    if (entity.rotation) {
        group.rotation.z = entity.rotation * Math.PI / 180;
    }

    if (entity.position) {
        group.position.x = entity.position.x;
        group.position.y = entity.position.y;
        group.position.z = entity.position.z;
    }

    for (let i = 0; i < block.entities.length; i++) {
        const childEntity = drawEntity(block.entities[i]);
        if (childEntity) group.add(childEntity);
    }

    return group;
}

function drawSpline(entity) {
    if (entity.controlPoints === undefined) return null;
    const color = getColor(entity);

    const points = getBSplinePolyline(entity.controlPoints, entity.degreeOfSplineCurve, entity.knotValues, 100, undefined);

    const geometry = new THREE.BufferGeometry().setFromPoints(points);
    const material = new THREE.LineBasicMaterial({ linewidth: 1, color: color });
    return new THREE.Line(geometry, material);
}

function drawEllipse(entity) {
    const color = getColor(entity);

    const xrad = Math.sqrt(Math.pow(entity.majorAxisEndPoint.x, 2) + Math.pow(entity.majorAxisEndPoint.y, 2));
    const yrad = xrad * entity.axisRatio;
    const rotation = Math.atan2(entity.majorAxisEndPoint.y, entity.majorAxisEndPoint.x);

    const curve = new THREE.EllipseCurve(
        entity.center.x, entity.center.y,
        xrad, yrad,
        entity.startAngle, entity.endAngle,
        false, // Always counterclockwise
        rotation
    );

    const points = curve.getPoints(50);
    const geometry = new THREE.BufferGeometry().setFromPoints(points);
    const material = new THREE.LineBasicMaterial({ linewidth: 1, color: color });

    // 创建要添加到场景中的最后一个对象
    return new THREE.Line(geometry, material);
}

function drawHatch(entity) {
    if (entity.isSolid) return

    // TODO 未实现
}

function drawDimension(entity) {
    if (!data.blocks) return;

    // console.log("drawDimension", entity.block)
    const block = data.blocks[entity.block];

    // 解析过的就存储起来，不再重复解析
    parsedBlocks.push(entity.block);

    if (!block || !block.entities) return null;

    const group = new THREE.Group();
    // if(entity.anchorPoint) {
    //     group.position.x = entity.anchorPoint.x;
    //     group.position.y = entity.anchorPoint.y;
    //     group.position.z = entity.anchorPoint.z;
    // }

    for (let i = 0; i < block.entities.length; i++) {
        const childEntity = drawEntity(block.entities[i]);
        if (childEntity) group.add(childEntity);
    }

    return group;
}

/** ------------------------------------------实体解析结束-------------------------------------------------------- **/

// 设置图层可见性
export function setLayerVisible(data: { layerName: string, visible: boolean }) {
    const group = scene.getObjectByName(data.layerName);
    if (group) group.visible = data.visible;
}

// 调用modules里的方法
export function callModuleMethod(data: { moduleName: string, methodName: string }) {
    const module = modules[data.moduleName];
    if (module && module[data.methodName]) {
        module[data.methodName](data);
    }
}

// 相机复位
export function resetCamera() {
    const viewPort = camera.userData.viewPort;

    if (!viewPort) return;

    camera.left = viewPort.left;
    camera.right = viewPort.right;
    camera.top = viewPort.top;
    camera.bottom = viewPort.bottom;

    camera.position.z = 1;
    camera.position.x = viewPort.center.x;
    camera.position.y = viewPort.center.y;

    modules.drawRect.controls.target.x = camera.position.x;
    modules.drawRect.controls.target.y = camera.position.y;
    modules.drawRect.controls.target.z = 0;
    modules.drawRect.controls.object.zoom = 1;
    modules.drawRect.controls.update();
}

//let start;
export function resize({ width, height }) {
    if (!camera || data) return;

    const hscale = width / state.width;
    const vscale = height / state.height;

    state.width = width;
    state.height = height;

    camera.top = (vscale * camera.top);
    camera.bottom = (vscale * camera.bottom);
    camera.left = (hscale * camera.left);
    camera.right = (hscale * camera.right);

    camera.updateProjectionMatrix();

    renderer.setSize(width, height, false);
    // composer.setSize(width, height);
    // finalComposer.setSize(width, height);

    render();
}

//
// function darkenNonBloomed(obj) {
//     if (obj.material && bloomLayer.test(obj.layers) === false) {
//         materials[obj.uuid] = obj.material;
//         obj.material = DarkMaterial;
//     }
// }
//
// function restoreMaterial(obj) {
//     if (materials[obj.uuid]) {
//         obj.material = materials[obj.uuid];
//         delete materials[obj.uuid];
//     }
// }

export function render() {
    renderer.autoClear = false;

    // scene.traverse(darkenNonBloomed);
    // composer.render();
    // scene.traverse(restoreMaterial);
    // finalComposer.render();
    renderer.render(scene, camera);
    renderer.render(helpScene, camera);

    renderer.autoClear = true;
}

export function stopRender() {
    renderer.setAnimationLoop(null)
}

export function renderLoop() {
    renderer.setAnimationLoop(render)
}

export function helpRender() {
    renderer.autoClear = false;
    renderer.render(helpScene, camera);
}

export function dispose() {
    data = undefined;
    font = undefined;

    renderer.setAnimationLoop(null)
    renderer?.dispose();
    scene.children.forEach((obj) => {
        scene.remove(obj);
    })
    camera.remove();
    scene.remove();
}

/** ---------------------------- 设置弹窗配置变化 ---------------------------------- */
export function changeClearColor(color: 0x000000 | 0xffffff) {
    options.bgColor = color;
    options.contrastColor = options.bgColor === 0x000000 ? 0xffffff : 0x000000;
    scene.background = new THREE.Color(options.bgColor);

    contrastEntity.forEach(mesh => {
        if (!mesh.material || !mesh.material.color) return;

        mesh.material.color = new THREE.Color(options.contrastColor);
    })
}