"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const doc_1 = require("prettier/doc");
const embed_1 = __importDefault(require("./embed"));
const { fill, group, hardline, indent, join, line, literalline, softline } = doc_1.builders;
const ignoreStartComment = "<!-- prettier-ignore-start -->";
const ignoreEndComment = "<!-- prettier-ignore-end -->";
function hasIgnoreRanges(comments) {
    if (!comments || comments.length === 0) {
        return false;
    }
    comments.sort((left, right) => left.startOffset - right.startOffset);
    let startFound = false;
    for (let idx = 0; idx < comments.length; idx += 1) {
        if (comments[idx].image === ignoreStartComment) {
            startFound = true;
        }
        else if (startFound && comments[idx].image === ignoreEndComment) {
            return true;
        }
    }
    return false;
}
function isWhitespaceIgnorable(node) {
    const { CData, Comment, reference } = node.children;
    return !CData && !reference && !hasIgnoreRanges(Comment);
}
function printIToken(path) {
    const node = path.getValue();
    return {
        offset: node.startOffset,
        startLine: node.startLine,
        endLine: node.endLine,
        printed: node.image
    };
}
function replaceNewlinesWithLiteralLines(content) {
    return content
        .split(/(\n)/g)
        .map((value, idx) => (idx % 2 === 0 ? value : literalline));
}
const printer = {
    embed: embed_1.default,
    print(path, opts, print) {
        const node = path.getValue();
        switch (node.name) {
            case "attribute": {
                const { Name, EQUALS, STRING } = node.children;
                return [Name[0].image, EQUALS[0].image, STRING[0].image];
            }
            case "chardata": {
                const { SEA_WS, TEXT } = node.children;
                const [{ image }] = SEA_WS || TEXT;
                return image
                    .split(/(\n)/g)
                    .map((value, index) => (index % 2 === 0 ? value : literalline));
            }
            case "content": {
                const nodePath = path;
                let fragments = nodePath.call((childrenPath) => {
                    let response = [];
                    const children = childrenPath.getValue();
                    if (children.CData) {
                        response = response.concat(childrenPath.map(printIToken, "CData"));
                    }
                    if (children.Comment) {
                        response = response.concat(childrenPath.map(printIToken, "Comment"));
                    }
                    if (children.chardata) {
                        response = response.concat(childrenPath.map((charDataPath) => ({
                            offset: charDataPath.getValue().location.startOffset,
                            printed: print(charDataPath)
                        }), "chardata"));
                    }
                    if (children.element) {
                        response = response.concat(childrenPath.map((elementPath) => ({
                            offset: elementPath.getValue().location.startOffset,
                            printed: print(elementPath)
                        }), "element"));
                    }
                    if (children.PROCESSING_INSTRUCTION) {
                        response = response.concat(childrenPath.map(printIToken, "PROCESSING_INSTRUCTION"));
                    }
                    if (children.reference) {
                        response = response.concat(childrenPath.map((referencePath) => {
                            const referenceNode = referencePath.getValue();
                            return {
                                offset: referenceNode.location.startOffset,
                                printed: (referenceNode.children.CharRef ||
                                    referenceNode.children.EntityRef)[0].image
                            };
                        }, "reference"));
                    }
                    return response;
                }, "children");
                const { Comment } = node.children;
                if (hasIgnoreRanges(Comment)) {
                    Comment.sort((left, right) => left.startOffset - right.startOffset);
                    const ignoreRanges = [];
                    let ignoreStart = null;
                    // Build up a list of ignored ranges from the original text based on the
                    // special prettier-ignore-* comments
                    Comment.forEach((comment) => {
                        if (comment.image === ignoreStartComment) {
                            ignoreStart = comment;
                        }
                        else if (ignoreStart && comment.image === ignoreEndComment) {
                            ignoreRanges.push({
                                start: ignoreStart.startOffset,
                                end: comment.endOffset
                            });
                            ignoreStart = null;
                        }
                    });
                    // Filter the printed children to only include the ones that are outside
                    // of each of the ignored ranges
                    fragments = fragments.filter((fragment) => ignoreRanges.every(({ start, end }) => fragment.offset < start || fragment.offset > end));
                    // Push each of the ignored ranges into the child list as its own element
                    // so that the original content is still included
                    ignoreRanges.forEach(({ start, end }) => {
                        const content = opts.originalText.slice(start, end + 1);
                        fragments.push({
                            offset: start,
                            printed: replaceNewlinesWithLiteralLines(content)
                        });
                    });
                }
                fragments.sort((left, right) => left.offset - right.offset);
                return group(fragments.map(({ printed }) => printed));
            }
            case "docTypeDecl": {
                const { DocType, Name, externalID, CLOSE } = node.children;
                const parts = [DocType[0].image, " ", Name[0].image];
                if (externalID) {
                    parts.push(" ", path.call(print, "children", "externalID", 0));
                }
                return group([...parts, CLOSE[0].image]);
            }
            case "document": {
                const { docTypeDecl, element, misc, prolog } = node.children;
                const fragments = [];
                if (docTypeDecl) {
                    fragments.push({
                        offset: docTypeDecl[0].location.startOffset,
                        printed: path.call(print, "children", "docTypeDecl", 0)
                    });
                }
                if (prolog) {
                    fragments.push({
                        offset: prolog[0].location.startOffset,
                        printed: path.call(print, "children", "prolog", 0)
                    });
                }
                if (misc) {
                    misc.forEach((node) => {
                        if (node.children.PROCESSING_INSTRUCTION) {
                            fragments.push({
                                offset: node.location.startOffset,
                                printed: node.children.PROCESSING_INSTRUCTION[0].image
                            });
                        }
                        else if (node.children.Comment) {
                            fragments.push({
                                offset: node.location.startOffset,
                                printed: node.children.Comment[0].image
                            });
                        }
                    });
                }
                if (element) {
                    fragments.push({
                        offset: element[0].location.startOffset,
                        printed: path.call(print, "children", "element", 0)
                    });
                }
                fragments.sort((left, right) => left.offset - right.offset);
                return [
                    join(hardline, fragments.map(({ printed }) => printed)),
                    hardline
                ];
            }
            case "element": {
                const { OPEN, Name, attribute, START_CLOSE, content, SLASH_OPEN, END_NAME, END, SLASH_CLOSE } = node.children;
                const parts = [OPEN[0].image, Name[0].image];
                if (attribute) {
                    const separator = opts.singleAttributePerLine ? hardline : line;
                    parts.push(indent([
                        line,
                        join(separator, path.map(print, "children", "attribute"))
                    ]));
                }
                // Determine the value that will go between the <, name, and attributes
                // of an element and the /> of an element.
                const space = opts.xmlSelfClosingSpace ? line : softline;
                if (SLASH_CLOSE) {
                    return group([...parts, space, SLASH_CLOSE[0].image]);
                }
                if (Object.keys(content[0].children).length === 0) {
                    return group([...parts, space, "/>"]);
                }
                const openTag = group([
                    ...parts,
                    opts.bracketSameLine ? "" : softline,
                    START_CLOSE[0].image
                ]);
                const closeTag = group([
                    SLASH_OPEN[0].image,
                    END_NAME[0].image,
                    END[0].image
                ]);
                if (opts.xmlWhitespaceSensitivity === "ignore" &&
                    isWhitespaceIgnorable(content[0])) {
                    const nodePath = path;
                    const fragments = nodePath.call((childrenPath) => {
                        const children = childrenPath.getValue();
                        let response = [];
                        if (children.Comment) {
                            response = response.concat(childrenPath.map(printIToken, "Comment"));
                        }
                        if (children.chardata) {
                            childrenPath.each((charDataPath) => {
                                const chardata = charDataPath.getValue();
                                if (!chardata.children.TEXT) {
                                    return;
                                }
                                const content = chardata.children.TEXT[0].image.trim();
                                const printed = group(content.split(/(\n)/g).map((value) => {
                                    if (value === "\n") {
                                        return literalline;
                                    }
                                    return fill(value
                                        .split(/\b( +)\b/g)
                                        .map((segment, index) => index % 2 === 0 ? segment : line));
                                }));
                                const location = chardata.location;
                                response.push({
                                    offset: location.startOffset,
                                    startLine: location.startLine,
                                    endLine: location.endLine,
                                    printed
                                });
                            }, "chardata");
                        }
                        if (children.element) {
                            response = response.concat(childrenPath.map((elementPath) => {
                                const location = elementPath.getValue().location;
                                return {
                                    offset: location.startOffset,
                                    startLine: location.startLine,
                                    endLine: location.endLine,
                                    printed: print(elementPath)
                                };
                            }, "element"));
                        }
                        if (children.PROCESSING_INSTRUCTION) {
                            response = response.concat(childrenPath.map(printIToken, "PROCESSING_INSTRUCTION"));
                        }
                        return response;
                    }, "children", "content", 0, "children");
                    fragments.sort((left, right) => left.offset - right.offset);
                    // If the only content of this tag is chardata, then use a softline so
                    // that we won't necessarily break (to allow <foo>bar</foo>).
                    if (fragments.length === 1 &&
                        (content[0].children.chardata || []).filter((chardata) => chardata.children.TEXT).length === 1) {
                        return group([
                            openTag,
                            indent([softline, fragments[0].printed]),
                            softline,
                            closeTag
                        ]);
                    }
                    if (fragments.length === 0) {
                        return group([...parts, space, "/>"]);
                    }
                    const docs = [];
                    let lastLine = fragments[0].startLine;
                    fragments.forEach((node) => {
                        if (node.startLine - lastLine >= 2) {
                            docs.push(hardline, hardline);
                        }
                        else {
                            docs.push(hardline);
                        }
                        docs.push(node.printed);
                        lastLine = node.endLine;
                    });
                    return group([openTag, indent(docs), hardline, closeTag]);
                }
                return group([
                    openTag,
                    indent(path.call(print, "children", "content", 0)),
                    closeTag
                ]);
            }
            case "externalID": {
                const { Public, PubIDLiteral, System, SystemLiteral } = node.children;
                if (System) {
                    return group([
                        System[0].image,
                        indent([line, SystemLiteral[0].image])
                    ]);
                }
                return group([
                    group([Public[0].image, indent([line, PubIDLiteral[0].image])]),
                    indent([line, SystemLiteral[0].image])
                ]);
            }
            case "prolog": {
                const { XMLDeclOpen, attribute, SPECIAL_CLOSE } = node.children;
                const parts = [XMLDeclOpen[0].image];
                if (attribute) {
                    parts.push(indent([
                        softline,
                        join(line, path.map(print, "children", "attribute"))
                    ]));
                }
                const space = opts.xmlSelfClosingSpace ? line : softline;
                return group([...parts, space, SPECIAL_CLOSE[0].image]);
            }
        }
    }
};
exports.default = printer;