import {Readable} from 'stream';
import DxfArrayScanner, {IGroup} from './DxfArrayScanner';
import AUTO_CAD_COLOR_INDEX from './AutoCadColorIndex';
import dimStyleCodes from './DimStyleCodes';

import Face from './entities/3dface';
import Arc from './entities/arc';
import AttDef from './entities/attdef';
import Attribute from './entities/attribute'
import Circle from './entities/circle';
import Dimension from './entities/dimension';
import Ellipse from './entities/ellipse';
import Hatch from './entities/hatch';
import Insert from './entities/insert';
import Line from './entities/line';
import LWPolyline from './entities/lwpolyline';
import MText from './entities/mtext';
import Point from './entities/point';
import Polyline from './entities/polyline';
import Solid from './entities/solid';
import Spline from './entities/spline';
import Text from './entities/text';
import Vertex from './entities/vertex';

import log from '@/utils/log/Logger';
import IGeometry, {EntityName, IEntity, IPoint} from './entities/geomtry';

export interface IBlock {
    entities: IEntity[];
    type: number;
    ownerHandle: string;
    // entities: any[];
    xrefPath: string;
    name: string;
    name2: string;
    handle: string;
    layer: string;
    position: IPoint;
    paperSpace: boolean;
}

export interface IViewPort {
    name: string;
    lowerLeftCorner: IPoint;
    upperRightCorner: IPoint;
    center: IPoint;
    snapBasePoint: IPoint;
    snapSpacing: IPoint;
    gridSpacing: IPoint;
    viewDirectionFromTarget: IPoint;
    viewTarget: IPoint;
    lensLength: number;
    frontClippingPlane: string | number | boolean;
    backClippingPlane: string | number | boolean;
    viewHeight: number;
    snapRotationAngle: number;
    viewTwistAngle: number;
    orthographicType: string;
    ucsOrigin: IPoint;
    ucsXAxis: IPoint;
    ucsYAxis: IPoint;
    renderMode: string;
    defaultLightingType: string;
    defaultLightingOn: string;
    ownerHandle: string;
    ambientColor: number;
    viewMode: string;
}

export interface IViewPortTableDefinition {
    tableRecordsProperty: 'viewPorts';
    tableName: 'viewPort';
    dxfSymbolName: 'VPORT';

    parseTableRecords(): IViewPort[];
}

export interface ILineType {
    name: string;
    description: string;
    pattern: string[];
    patternLength: number;
}

export interface ILineTypeTableDefinition {
    tableRecordsProperty: 'lineTypes';
    tableName: 'lineType';
    dxfSymbolName: 'LTYPE';

    parseTableRecords(): Record<string, ILineType>;
}

export interface ILayer {
    name: string;
    visible: boolean;
    colorIndex: number;
    color: number;
    frozen: boolean;
}

export interface ILayerTableDefinition {
    tableRecordsProperty: 'layers';
    tableName: 'layer';
    dxfSymbolName: 'LAYER';

    parseTableRecords(): Record<string, ILayer>;
}

export interface ITableDefinitions {
    VPORT: IViewPortTableDefinition;
    LTYPE: ILineTypeTableDefinition;
    LAYER: ILayerTableDefinition;
    DIMSTYLE: any;
    STYLE: any;
}

export interface IBaseTable {
    handle: string;
    ownerHandle: string;
}

export interface IViewPortTable extends IBaseTable {
    viewPorts: IViewPort[];
}

export interface ILayerTypesTable extends IBaseTable {
    lineTypes: Record<string, ILineType>;
}

export interface ILayersTable extends IBaseTable {
    layers: Record<string, ILayer>;
}

export interface ITables {
    viewPort: IViewPortTable;
    lineType: ILayerTypesTable;
    layer: ILayersTable;
}

export type ITable = IViewPortTable | ILayerTypesTable | ILayersTable;

export interface IDxf {
    header: Record<string, IPoint | number>;
    entities: IEntity[];
    blocks: Record<string, IBlock>;
    tables: ITables;
}

function registerDefaultEntityHandlers(dxfParser: DxfParser) {
    // 这里支持的实体(一些实体代码仍然被重构到这个流中)
    dxfParser.registerEntityHandler(Face);
    dxfParser.registerEntityHandler(Arc);
    dxfParser.registerEntityHandler(AttDef);
    dxfParser.registerEntityHandler(Attribute);
    dxfParser.registerEntityHandler(Circle);
    dxfParser.registerEntityHandler(Dimension);
    dxfParser.registerEntityHandler(Ellipse);
    dxfParser.registerEntityHandler(Hatch);
    dxfParser.registerEntityHandler(Insert);
    dxfParser.registerEntityHandler(Line);
    dxfParser.registerEntityHandler(LWPolyline);
    dxfParser.registerEntityHandler(MText);
    dxfParser.registerEntityHandler(Point);
    dxfParser.registerEntityHandler(Polyline);
    dxfParser.registerEntityHandler(Solid);
    dxfParser.registerEntityHandler(Spline);
    dxfParser.registerEntityHandler(Text);
    dxfParser.registerEntityHandler(Vertex);
}

export default class DxfParser {
    private _entityHandlers = {} as Record<EntityName, IGeometry>;

    constructor() {
        registerDefaultEntityHandlers(this);
    }

    public parse(source: string | Readable) {
        if (typeof source === 'string') {
            return this._parse(source);
        } else {
            log.error('无法读取dxf源的类型: `' + typeof (source));
            return null;
        }
    }

    public registerEntityHandler(handlerType: new () => IGeometry) {
        const instance = new handlerType();
        this._entityHandlers[instance.ForEntityName] = instance;
    }

    public parseSync(source: string) {
        return this.parse(source);
    }

    public parseStream(stream: Readable) {
        let dxfString = "";
        const self = this;
        return new Promise<IDxf>((res, rej) => {

            stream.on('data', (chunk) => {
                dxfString += chunk;
            });
            stream.on('end', () => {
                try {
                    res(self._parse(dxfString));
                } catch (err) {
                    rej(err);
                }
            });
            stream.on('error', (err) => {
                rej(err);
            });
        });
    }

    private _parse(dxfString: string) {
        const dxf = {} as IDxf;
        let lastHandle = 0;
        const dxfLinesArray = dxfString.split(/\r\n|\r|\n/g);

        const scanner = new DxfArrayScanner(dxfLinesArray);
        if (!scanner.hasNext()) {
            log.error('当前 CAD 文件为空文件');
            return dxf;
        }

        const self = this;
        let curr: IGroup;

        function parseAll() {
            curr = scanner.next();
            while (!scanner.isEOF()) {
                if (curr.code === 0 && curr.value === 'SECTION') {
                    curr = scanner.next();

                    // 确保我们读的是段代码
                    if (curr.code !== 2) {
                        log.error(`Unexpected code ${debugCode(curr) } after 0:SECTION`);
                        curr = scanner.next();
                        continue;
                    }

                    if (curr.value === 'HEADER') {
                        dxf.header = parseHeader();
                    } else if (curr.value === 'BLOCKS') {
                        dxf.blocks = parseBlocks();
                    } else if (curr.value === 'ENTITIES') {
                        dxf.entities = parseEntities(false);
                    } else if (curr.value === 'TABLES') {
                        dxf.tables = parseTables();
                    } else if (curr.value === 'EOF') {
                        log.debug('EOF');
                    } else {
                        log.warn('Skipping section ' + curr.value);
                    }
                } else {
                    curr = scanner.next();
                }
                // If is a new section
            }
        }

        /**
         *
         * @return {object} header
         */
        function parseHeader() {
            // interesting variables:
            //  $ACADVER, $VIEWDIR, $VIEWSIZE, $VIEWCTR, $TDCREATE, $TDUPDATE
            // http://www.autodesk.com/techpubs/autocad/acadr14/dxf/header_section_al_u05_c.htm
            // Also see VPORT table entries
            let currVarName = null as null | string;
            let currVarValue = null as null | IPoint | number;
            const header = {} as Record<string, IPoint | number>;
            // loop through header variables
            curr = scanner.next();

            while (true) {
                if (groupIs(curr, 0, 'ENDSEC')) {
                    if (currVarName) header[currVarName as string] = currVarValue!;
                    break;
                } else if (curr.code === 9) {
                    if (currVarName) header[currVarName as string] = currVarValue!;
                    currVarName = curr.value as string;
                    // Filter here for particular variables we are interested in
                } else {
                    if (curr.code === 10) {
                        currVarValue = {x: curr.value as number} as IPoint;
                    } else if (curr.code === 20) {
                        (currVarValue as IPoint).y = curr.value as number;
                    } else if (curr.code === 30) {
                        (currVarValue as IPoint).z = curr.value as number;
                    } else {
                        currVarValue = curr.value as number;
                    }
                }
                curr = scanner.next();
            }
            // console.log(util.inspect(header, { colors: true, depth: null }));
            curr = scanner.next(); // swallow up ENDSEC
            return header;
        }

        function parseBlocks() {
            const blocks = {} as Record<string, IBlock>;

            curr = scanner.next();

            while (curr.value !== 'EOF') {
                if (groupIs(curr, 0, 'ENDSEC')) {
                    break;
                }

                if (groupIs(curr, 0, 'BLOCK')) {
                    const block = parseBlock();
                    ensureHandle(block);
                    if (!block.name) {
                        // log.error('block with handle "' + block.handle + '" is missing a name.');
                        // block.name = 'InvalidBlockName-' + block.ownerHandle;
                    }else{
                        blocks[block.name] = block;
                    }
                } else {
                    logUnhandledGroup(curr);
                    curr = scanner.next();
                }
            }
            return blocks;
        }

        function parseBlock() {
            const block = {} as IBlock;
            curr = scanner.next();

            while (curr.value !== 'EOF') {
                switch (curr.code) {
                    case 1:
                        block.xrefPath = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 2:
                        block.name = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 3:
                        block.name2 = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 5:
                        block.handle = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 8:
                        block.layer = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 10:
                        block.position = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 67:
                        block.paperSpace = (curr.value && curr.value == 1) ? true : false;
                        curr = scanner.next();
                        break;
                    case 70:
                        if (curr.value != 0) {
                            //if(curr.value & BLOCK_ANONYMOUS_FLAG) console.log('  Anonymous block');
                            //if(curr.value & BLOCK_NON_CONSTANT_FLAG) console.log('  Non-constant attributes');
                            //if(curr.value & BLOCK_XREF_FLAG) console.log('  Is xref');
                            //if(curr.value & BLOCK_XREF_OVERLAY_FLAG) console.log('  Is xref overlay');
                            //if(curr.value & BLOCK_EXTERNALLY_DEPENDENT_FLAG) console.log('  Is externally dependent');
                            //if(curr.value & BLOCK_RESOLVED_OR_DEPENDENT_FLAG) console.log('  Is resolved xref or dependent of an xref');
                            //if(curr.value & BLOCK_REFERENCED_XREF) console.log('  This definition is a referenced xref');
                            block.type = curr.value as number;
                        }
                        curr = scanner.next();
                        break;
                    case 100:
                        // ignore class markers
                        curr = scanner.next();
                        break;
                    case 330:
                        block.ownerHandle = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 0:
                        if (curr.value == 'ENDBLK')
                            break;
                        block.entities = parseEntities(true);
                        break;
                    default:
                        logUnhandledGroup(curr);
                        curr = scanner.next();
                }

                if (groupIs(curr, 0, 'ENDBLK')) {
                    curr = scanner.next();
                    break;
                }
            }
            return block;
        }

        /**
         * parseTables
         * @return {Object} Object representing tables
         */
        function parseTables() {
            const tables = {} as ITables;
            curr = scanner.next();
            while (curr.value !== 'EOF') {
                if (groupIs(curr, 0, 'ENDSEC'))
                    break;

                if (groupIs(curr, 0, 'TABLE')) {
                    curr = scanner.next();

                    const tableDefinition = tableDefinitions[curr.value as keyof ITableDefinitions];
                    if (tableDefinition) {
                        tables[tableDefinitions[curr.value as keyof ITableDefinitions].tableName] = parseTable(curr);
                    } else {
                        // log.debug('Unhandled Table ' + curr.value);
                    }
                } else {
                    // else ignored
                    curr = scanner.next();
                }
            }

            curr = scanner.next();
            return tables;
        }

        const END_OF_TABLE_VALUE = 'ENDTAB';

        function parseTable<T extends IBaseTable = ITable>(group: IGroup) {
            const tableDefinition = tableDefinitions[group.value as keyof ITableDefinitions];
            const table = {} as T;
            let expectedCount = 0;

            curr = scanner.next();
            while (!groupIs(curr, 0, END_OF_TABLE_VALUE)) {
                switch (curr.code) {
                    case 5:
                        table.handle = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 330:
                        table.ownerHandle = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 100:
                        if (curr.value === 'AcDbSymbolTable') {
                            // ignore
                            curr = scanner.next();
                        } else {
                            logUnhandledGroup(curr);
                            curr = scanner.next();
                        }
                        break;
                    case 70:
                        expectedCount = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 0:
                        if (curr.value === tableDefinition.dxfSymbolName) {
                            table[tableDefinition.tableRecordsProperty] = tableDefinition.parseTableRecords();
                        } else {
                            logUnhandledGroup(curr);
                            curr = scanner.next();
                        }
                        break;
                    default:
                        logUnhandledGroup(curr);
                        curr = scanner.next();
                }
            }
            const tableRecords = table[tableDefinition.tableRecordsProperty];
            if (tableRecords) {
                let actualCount = (() => {
                    if (tableRecords.constructor === Array) {
                        return tableRecords.length;
                    } else if (typeof (tableRecords) === 'object') {
                        return Object.keys(tableRecords).length;
                    }
                    return undefined;
                })();
                if (expectedCount !== actualCount) log.warn('Parsed ' + actualCount + ' ' + tableDefinition.dxfSymbolName + '\'s but expected ' + expectedCount);
            }
            curr = scanner.next();
            return table;
        }

        function parseViewPortRecords() {
            const viewPorts = [] as IViewPort[]; // 多个表项可以具有相同的名称，表示多个视区配置
            let viewPort = {} as IViewPort;

            curr = scanner.next();
            while (!groupIs(curr, 0, END_OF_TABLE_VALUE)) {

                switch (curr.code) {
                    case 2: // 视口名
                        viewPort.name = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 10: // 视口的左下角
                        viewPort.lowerLeftCorner = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 11: // 视口右上角
                        viewPort.upperRightCorner = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 12: // 视口中心点（在 DCS 中）
                        viewPort.center = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 13: // 捕捉基点（在 DCS 中）
                        viewPort.snapBasePoint = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 14: // 捕捉间距 X 和 Y
                        viewPort.snapSpacing = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 15: // 栅格间距 X 和 Y
                        viewPort.gridSpacing = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 16: // 相对于目标点的观察方向（在 WCS 中）
                        viewPort.viewDirectionFromTarget = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 17: //观察目标点（在 WCS 中）
                        viewPort.viewTarget = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 42: // 焦距
                        viewPort.lensLength = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 43: //前向剪裁平面（距目标点的偏移）
                        viewPort.frontClippingPlane = curr.value;
                        curr = scanner.next();
                        break;
                    case 44: // 后向剪裁平面（距目标点的偏移）
                        viewPort.backClippingPlane = curr.value;
                        curr = scanner.next();
                        break;
                    case 45: // 视图高度
                        viewPort.viewHeight = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 50: // 捕捉旋转角度
                        viewPort.snapRotationAngle = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 51: // 视图扭转角度
                        viewPort.viewTwistAngle = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 71: // 视图模式（参见 VIEWMODE 系统变量）
                        viewPort.viewMode = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 79: // UCS 的正交类型  0 = UCS 不正交 1 = 俯视图；2 = 仰视图 3 = 主视图；4 = 后视图 5 = 左视图；6 = 右视图
                        viewPort.orthographicType = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 110: // UCS 原点（在 DCS 中）
                        viewPort.ucsOrigin = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 111: // UCS X 轴
                        viewPort.ucsXAxis = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 112: // UCS Y 轴
                        viewPort.ucsYAxis = parsePoint(curr);
                        curr = scanner.next();
                        break;
                    case 281:
                        /*
                        * 渲染模式： 0 = 二维优化（传统二维） 1 = 线框图 2 = 隐藏线 3 = 平面着色 4 = 体着色 5 = 带线框平面着色 6 = 带线框体着色
                        * 所有非二维优化渲染模式均使用新三维图形管道。这些值直接与 SHADEMODE 命令和 AcDbAbstractViewTableRecord::RenderMode 枚举相对应
                        */
                        viewPort.renderMode = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 292:
                        viewPort.defaultLightingOn = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 330:
                        viewPort.ownerHandle = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 63: // These are all ambient color. Perhaps should be a gradient when multiple are set.
                    case 421:
                    case 431:
                        viewPort.ambientColor = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 0:
                        // New ViewPort
                        if (curr.value === 'VPORT') {
                            viewPorts.push(viewPort);
                            viewPort = {} as IViewPort;
                            curr = scanner.next();
                        }
                        break;
                    default:
                        logUnhandledGroup(curr);
                        curr = scanner.next();
                        break;
                }
            }
            // Note: do not call scanner.next() here,
            //  parseTable() needs the current group
            viewPorts.push(viewPort);

            return viewPorts;
        }

        function parseLineTypes() {
            const ltypes = {} as Record<string, ILineType>;
            let ltype = {} as ILineType;
            let length = 0;
            let ltypeName: string;

            curr = scanner.next();
            while (!groupIs(curr, 0, 'ENDTAB')) {

                switch (curr.code) {
                    case 2:
                        ltype.name = curr.value as string;
                        ltypeName = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 3:
                        ltype.description = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 73: // Number of elements for this line type (dots, dashes, spaces);
                        length = curr.value as number;
                        if (length > 0) ltype.pattern = [];
                        curr = scanner.next();
                        break;
                    case 40: // total pattern length
                        ltype.patternLength = curr.value as number;
                        curr = scanner.next();
                        break;
                    case 49:
                        ltype.pattern.push(curr.value as string);
                        curr = scanner.next();
                        break;
                    case 0:
                        if (length > 0 && length !== ltype.pattern.length) log.warn('lengths do not match on LTYPE pattern');
                        ltypes[ltypeName!] = ltype;
                        ltype = {} as ILineType;
                        curr = scanner.next();
                        break;
                    default:
                        curr = scanner.next();
                }
            }

            ltypes[ltypeName!] = ltype;
            return ltypes;
        }

        function parseLayers() {
            const layers = {} as Record<string, ILayer>;
            let layer = {} as ILayer;
            let layerName: string | undefined;

            curr = scanner.next();
            while (!groupIs(curr, 0, 'ENDTAB')) {

                switch (curr.code) {
                    case 2: // layer name
                        layer.name = curr.value as string;
                        layerName = curr.value as string;
                        curr = scanner.next();
                        break;
                    case 62: // color, visibility
                        // @ts-ignore
                        layer.visible = curr.value >= 0;
                        // TODO 0 and 256 are BYBLOCK and BYLAYER respectively. Need to handle these values for layers?.
                        layer.colorIndex = Math.abs(curr.value as number);
                        layer.color = getAcadColor(layer.colorIndex as number);
                        curr = scanner.next();
                        break;
                    case 70: // frozen layer
                        layer.frozen = (((curr.value as number) & 1) != 0 || ((curr.value as number) & 2) != 0);
                        curr = scanner.next();
                        break;
                    case 0:
                        // New Layer
                        if (curr.value === 'LAYER') {
                            layers[layerName!] = layer;
                            layer = {} as ILayer;
                            layerName = undefined;
                            curr = scanner.next();
                        }
                        break;
                    default:
                        logUnhandledGroup(curr);
                        curr = scanner.next();
                        break;
                }
            }
            // Note: do not call scanner.next() here,
            //  parseLayerTable() needs the current group
            layers[layerName!] = layer;

            return layers;
        }

        function parseDimStyles() {
            let dimStyles = {},
                styleName: string | undefined,
                style: any = {};

            curr = scanner.next();
            while (!groupIs(curr, 0, 'ENDTAB')) {
                if (dimStyleCodes.has(curr.code)) {
                    style[dimStyleCodes.get(curr.code) as string] = curr.value
                    curr = scanner.next();
                } else {
                    switch (curr.code) {
                        case 2: // style name
                            style.name = curr.value;
                            styleName = curr.value as string;
                            curr = scanner.next();
                            break;
                        case 0:
                            // New style
                            if (curr.value === 'DIMSTYLE') {
                                // @ts-ignore
                                dimStyles[styleName] = style;
                                style = {};
                                styleName = undefined;
                                curr = scanner.next();
                            }
                            break;
                        default:
                            logUnhandledGroup(curr);
                            curr = scanner.next();
                            break;
                    }
                }
            }
            // Note: do not call scanner.next() here,
            //  parseLayerTable() needs the current group
            dimStyles[styleName as string] = style;

            return dimStyles;
        }

        const parseStyles = function () {
            const styles = {};
            let style: any = {};
            let styleName;

            curr = scanner.next();
            while (!groupIs(curr, 0, END_OF_TABLE_VALUE)) {
                switch (curr.code) {
                    case 100:
                        style.subClassMarker = curr.value;
                        curr = scanner.next();
                        break;
                    case 2:
                        style.styleName = curr.value;
                        styleName = curr.value;
                        curr = scanner.next();
                        break;
                    case 70:
                        style.standardFlag = curr.value;
                        curr = scanner.next();
                        break;
                    case 40:
                        style.fixedTextHeight = curr.value;
                        curr = scanner.next();
                        break;
                    case 41:
                        style.widthFactor = curr.value;
                        curr = scanner.next();
                        break;
                    case 50:
                        style.obliqueAngle = curr.value;
                        curr = scanner.next();
                        break;
                    case 71:
                        style.textGenerationFlag = curr.value;
                        curr = scanner.next();
                        break;
                    case 42:
                        style.lastHeight = curr.value;
                        curr = scanner.next();
                        break;
                    case 3:
                        style.font = curr.value;
                        curr = scanner.next();
                        break;
                    case 4:
                        style.bigFont = curr.value;
                        curr = scanner.next();
                        break;
                    case 1071:
                        style.extendedFont = curr.value;
                        curr = scanner.next();
                        break;
                    case 0:
                        if (curr.value === 'STYLE') {
                            styles[styleName] = style;
                            style = {};
                            styleName = undefined;
                            curr = scanner.next();
                        }
                        break;
                    default:
                        logUnhandledGroup(curr);
                        curr = scanner.next();
                        break;
                }
            }
            styles[styleName] = style;
            return styles;
        };

        const tableDefinitions = {
            VPORT: {
                tableRecordsProperty: 'viewPorts',
                tableName: 'viewPort',
                dxfSymbolName: 'VPORT',
                parseTableRecords: parseViewPortRecords
            },
            LTYPE: {
                tableRecordsProperty: 'lineTypes',
                tableName: 'lineType',
                dxfSymbolName: 'LTYPE',
                parseTableRecords: parseLineTypes
            },
            LAYER: {
                tableRecordsProperty: 'layers',
                tableName: 'layer',
                dxfSymbolName: 'LAYER',
                parseTableRecords: parseLayers
            },
            DIMSTYLE: {
                tableRecordsProperty: 'dimStyles',
                tableName: 'dimstyle',
                dxfSymbolName: 'DIMSTYLE',
                parseTableRecords: parseDimStyles
            },
            STYLE: {
                tableRecordsProperty: 'styles',
                tableName: 'style',
                dxfSymbolName: 'STYLE',
                parseTableRecords: parseStyles,
            },
        } as ITableDefinitions;

        /**
         * 在解析器首次读取0:ENTITIES组后调用。扫描器应该已经在第一个实体的开始。
         * @return {Array} the resulting entities
         */
        function parseEntities(forBlock: boolean) {
            const entities = [] as IEntity[];

            const endingOnValue = forBlock ? 'ENDBLK' : 'ENDSEC';

            if (!forBlock) {
                curr = scanner.next();
            }
            while (true) {
                if (curr.code === 0) {
                    if (curr.value === endingOnValue) {
                        break;
                    }

                    const handler = self._entityHandlers[curr.value as EntityName];
                    if (handler != null) {
                        const entity = handler.parseEntity(scanner, curr);
                        curr = scanner.lastReadGroup!;
                        ensureHandle(entity);
                        entities.push(entity);
                    } else {
                        // log.debug('Unhandled entity ' + curr.value);
                        curr = scanner.next();
                        continue;
                    }
                } else {
                    // ignored lines from unsupported entity
                    curr = scanner.next();
                }
            }
            if (endingOnValue == 'ENDSEC') curr = scanner.next(); // swallow up ENDSEC, but not ENDBLK
            return entities;
        }

        /**
         * 解析一个2D或3D点.
         * 如果它是3D的，将其作为具有x， y和（有时）z属性的对象返回。
         * 假定当前组是被读入点的x，并且scanner.next（）将返回y。
         * 解析器将自动确定是否存在z点。
         * @return {Object} 二维或三维点作为具有 x、y[,z] 的对象
         */
        function parsePoint(curr: IGroup) {
            const point = {} as IPoint;
            let code = curr.code;

            point.x = curr.value as number;

            code += 10;
            curr = scanner.next();
            if (curr.code != code)
                throw new Error('Expected code for point value to be ' + code +
                    ' but got ' + curr.code + '.');
            point.y = curr.value as number;

            code += 10;
            curr = scanner.next();
            if (curr.code != code) {
                scanner.rewind();
                return point;
            }
            point.z = curr.value as number;

            return point;
        }

        function ensureHandle(entity: IEntity | IBlock) {
            if (!entity) throw new TypeError('entity cannot be undefined or null');

            if (!entity.handle) entity.handle = lastHandle++;
        }

        parseAll();
        return dxf;
    }
}

function groupIs(group: IGroup, code: number, value: string | number | boolean) {
    return group.code === code && group.value === value;
}

// @ts-ignore
function logUnhandledGroup(curr: IGroup) {
    // log.debug('unhandled group ' + debugCode(curr));
}


function debugCode(curr: IGroup) {
    return curr.code + ':' + curr.value;
}

/**
 * Returns the truecolor value of the given AutoCad color index value
 * @return {Number} truecolor value as a number
 */
function getAcadColor(index: number) {
    return AUTO_CAD_COLOR_INDEX[index];
}

// const BLOCK_ANONYMOUS_FLAG = 1;
// const BLOCK_NON_CONSTANT_FLAG = 2;
// const BLOCK_XREF_FLAG = 4;
// const BLOCK_XREF_OVERLAY_FLAG = 8;
// const BLOCK_EXTERNALLY_DEPENDENT_FLAG = 16;
// const BLOCK_RESOLVED_OR_DEPENDENT_FLAG = 32;
// const BLOCK_REFERENCED_XREF = 64;


/* Notes */
// Code 6 of an entity indicates inheritance of properties (eg. color).
//   BYBLOCK means inherits from block
//   BYLAYER (default) mean inherits from layer