package com.trafficaudit.holiday.service;

import org.springframework.stereotype.Service;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

@Service
public class HolidayTrendWordService {

    private static final String WORD_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
    private static final String DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/main";
    private static final String WORD_DRAWING_NS = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
    private static final String REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
    private static final String PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships";

    public byte[] generate(byte[] templateBytes, int year, List<DocumentBlock> blocks) {
        try {
            byte[] documentXml = readEntry(templateBytes, "word/document.xml");
            Document document = parse(documentXml);
            Element body = firstElement(document.getDocumentElement(), "body");
            if (body == null) throw new IllegalArgumentException("走势图模板缺少正文");

            TemplateParts parts = TemplateParts.from(document, body);
            Map<String, byte[]> media = new LinkedHashMap<>();
            List<ImageReference> imageReferences = new ArrayList<>();
            int imageIndex = 1;
            for (DocumentBlock block : blocks) {
                if (!(block instanceof ChartBlock)) continue;
                String imageName = "image" + imageIndex++ + ".png";
                imageReferences.add(new ImageReference("rId" + (100 + imageIndex - 2),
                        "media/" + imageName, ((ChartBlock) block).getPng()));
                media.put("word/media/" + imageName, ((ChartBlock) block).getPng());
            }

            Element sectPr = directChild(body, "sectPr");
            List<Node> removals = directChildren(body);
            for (Node node : removals) {
                if (node != sectPr) body.removeChild(node);
            }

            appendClone(body, parts.titleLine, year + "年“十一”假期全省综合运输客流量", sectPr);
            appendClone(body, parts.subtitleLine, null, sectPr);
            appendClone(body, parts.titleBlank, null, sectPr);

            int chartCursor = 0;
            int chartsOnPage = 0;
            for (int blockIndex = 0; blockIndex < blocks.size(); blockIndex++) {
                DocumentBlock block = blocks.get(blockIndex);
                if (block instanceof PageBreakBlock) {
                    appendPageBreak(body, sectPr);
                    chartsOnPage = 0;
                } else if (block instanceof SectionBlock) {
                    appendClone(body, parts.sectionTemplate, ((SectionBlock) block).getText(), sectPr, true);
                } else if (block instanceof ChartBlock) {
                    ChartBlock chart = (ChartBlock) block;
                    Element titleTemplate = chart.isCompact()
                            ? parts.compactTitleTemplate : parts.lineTitleTemplate;
                    Element imageTemplate = chart.isCompact()
                            ? parts.compactImageTemplate : parts.lineImageTemplate;
                    appendClone(body, titleTemplate, chart.getTitle(), sectPr);
                    Element imageParagraph = clone(imageTemplate);
                    ImageReference imageReference = imageReferences.get(chartCursor++);
                    bindImage(imageParagraph, imageReference, chart.getTitle(), chartCursor,
                            ((ChartBlock) block).getImageSize());
                    body.insertBefore(imageParagraph, sectPr);
                    appendClone(body, parts.chartBlank, null, sectPr);
                    chartsOnPage++;
                    boolean firstChartPageBreak = chartCursor == 1
                            && needsAutomaticPageBreak(blocks, blockIndex + 1);
                    if (firstChartPageBreak
                            || chartsOnPage >= 2
                            && needsAutomaticPageBreak(blocks, blockIndex + 1)) {
                        appendPageBreak(body, sectPr);
                        chartsOnPage = 0;
                    }
                }
            }

            byte[] updatedDocument = serialize(document);
            byte[] updatedRels = buildRelationships(templateBytes, imageReferences);
            Map<String, byte[]> replacements = new HashMap<>();
            replacements.put("word/document.xml", updatedDocument);
            replacements.put("word/_rels/document.xml.rels", updatedRels);
            replacements.putAll(media);
            return rewriteZip(templateBytes, replacements);
        } catch (Exception e) {
            throw new IllegalArgumentException("走势图文档生成失败: " + e.getMessage(), e);
        }
    }

    private byte[] buildRelationships(byte[] templateBytes, List<ImageReference> imageReferences) throws Exception {
        Document rels = parse(readEntry(templateBytes, "word/_rels/document.xml.rels"));
        Element root = rels.getDocumentElement();
        NodeList children = root.getChildNodes();
        List<Node> removals = new ArrayList<>();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node instanceof Element) {
                Element element = (Element) node;
                if ("Relationship".equals(element.getLocalName())
                        && element.getAttribute("Type").endsWith("/image")) {
                    removals.add(node);
                }
            }
        }
        for (Node node : removals) root.removeChild(node);
        for (ImageReference reference : imageReferences) {
            Element relationship = rels.createElementNS(PACKAGE_REL_NS, "Relationship");
            relationship.setAttribute("Id", reference.getRelationshipId());
            relationship.setAttribute("Type",
                    "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image");
            relationship.setAttribute("Target", reference.getTarget());
            root.appendChild(relationship);
        }
        return serialize(rels);
    }

    private void bindImage(Element paragraph, ImageReference reference, String title, int index,
                           ImageSize imageSize) {
        Element blip = firstElement(paragraph, "blip");
        if (blip == null) throw new IllegalArgumentException("走势图模板图片节点缺失");
        blip.setAttributeNS(REL_NS, "r:embed", reference.getRelationshipId());
        Element srcRect = firstElement(paragraph, "srcRect");
        if (srcRect != null) srcRect.getParentNode().removeChild(srcRect);
        resizeDrawing(paragraph, imageSize);
        Element docPr = firstElement(paragraph, "docPr");
        if (docPr != null) {
            docPr.setAttribute("id", String.valueOf(1000 + index));
            docPr.setAttribute("name", title);
            docPr.setAttribute("descr", title);
        }
    }

    private void resizeDrawing(Element paragraph, ImageSize imageSize) {
        if (imageSize == null) return;
        NodeList extents = paragraph.getElementsByTagNameNS(WORD_DRAWING_NS, "extent");
        for (int i = 0; i < extents.getLength(); i++) {
            Element extent = (Element) extents.item(i);
            extent.setAttribute("cx", String.valueOf(imageSize.getWidth()));
            extent.setAttribute("cy", String.valueOf(imageSize.getHeight()));
        }
        NodeList transforms = paragraph.getElementsByTagNameNS(DRAWING_NS, "xfrm");
        for (int i = 0; i < transforms.getLength(); i++) {
            Element transform = (Element) transforms.item(i);
            Element extent = firstElement(transform, "ext");
            if (extent == null) continue;
            extent.setAttribute("cx", String.valueOf(imageSize.getWidth()));
            extent.setAttribute("cy", String.valueOf(imageSize.getHeight()));
        }
    }

    private void appendClone(Element body, Element template, String text, Element before) {
        appendClone(body, template, text, before, false);
    }

    private void appendClone(Element body, Element template, String text, Element before,
                             boolean removeNumbering) {
        if (template == null) return;
        Element copy = clone(template);
        if (removeNumbering) removeNumbering(copy);
        if (text != null) setParagraphText(copy, text);
        body.insertBefore(copy, before);
    }

    private void removeNumbering(Element paragraph) {
        NodeList numbered = paragraph.getElementsByTagNameNS(WORD_NS, "numPr");
        while (numbered.getLength() > 0) {
            Node node = numbered.item(0);
            node.getParentNode().removeChild(node);
        }
    }

    private boolean needsAutomaticPageBreak(List<DocumentBlock> blocks, int nextIndex) {
        if (nextIndex >= blocks.size()) return false;
        return !(blocks.get(nextIndex) instanceof PageBreakBlock);
    }

    private void appendPageBreak(Element body, Element before) {
        Document document = body.getOwnerDocument();
        Element paragraph = document.createElementNS(WORD_NS, "w:p");
        Element run = document.createElementNS(WORD_NS, "w:r");
        Element br = document.createElementNS(WORD_NS, "w:br");
        br.setAttributeNS(WORD_NS, "w:type", "page");
        run.appendChild(br);
        paragraph.appendChild(run);
        body.insertBefore(paragraph, before);
    }

    private void setParagraphText(Element paragraph, String text) {
        Element pPr = firstDirectChild(paragraph, "pPr");
        Element firstRun = firstDirectChild(paragraph, "r");
        Element rPr = firstRun == null ? null : firstDirectChild(firstRun, "rPr");
        List<Node> removals = new ArrayList<>();
        Node child = paragraph.getFirstChild();
        while (child != null) {
            Node next = child.getNextSibling();
            if (child != pPr) removals.add(child);
            child = next;
        }
        for (Node node : removals) paragraph.removeChild(node);
        Element run = paragraph.getOwnerDocument().createElementNS(WORD_NS, "w:r");
        if (rPr != null) run.appendChild(rPr.cloneNode(true));
        Element t = paragraph.getOwnerDocument().createElementNS(WORD_NS, "w:t");
        t.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
        t.setTextContent(text);
        run.appendChild(t);
        paragraph.appendChild(run);
    }

    private Element clone(Element source) {
        return (Element) source.cloneNode(true);
    }

    private byte[] rewriteZip(byte[] source, Map<String, byte[]> replacements) throws Exception {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        Map<String, Boolean> seen = new HashMap<>();
        try (ZipInputStream input = new ZipInputStream(new ByteArrayInputStream(source));
             ZipOutputStream zipOutput = new ZipOutputStream(output)) {
            ZipEntry entry;
            byte[] buffer = new byte[8192];
            while ((entry = input.getNextEntry()) != null) {
                seen.put(entry.getName(), Boolean.TRUE);
                byte[] replacement = replacements.get(entry.getName());
                if (isGeneratedChartImage(entry.getName()) && replacement == null) continue;
                zipOutput.putNextEntry(new ZipEntry(entry.getName()));
                if (replacement != null) {
                    zipOutput.write(replacement);
                } else {
                    int length;
                    while ((length = input.read(buffer)) > 0) {
                        zipOutput.write(buffer, 0, length);
                    }
                }
                zipOutput.closeEntry();
            }
            for (Map.Entry<String, byte[]> replacement : replacements.entrySet()) {
                if (Boolean.TRUE.equals(seen.get(replacement.getKey()))) continue;
                zipOutput.putNextEntry(new ZipEntry(replacement.getKey()));
                zipOutput.write(replacement.getValue());
                zipOutput.closeEntry();
            }
        }
        return output.toByteArray();
    }

    private boolean isGeneratedChartImage(String entryName) {
        return entryName != null && entryName.matches("word/media/image[0-9]+\\.png");
    }

    private byte[] readEntry(byte[] zipBytes, String entryName) throws Exception {
        try (ZipInputStream input = new ZipInputStream(new ByteArrayInputStream(zipBytes))) {
            ZipEntry entry;
            while ((entry = input.getNextEntry()) != null) {
                if (entryName.equals(entry.getName())) return readAll(input);
            }
        }
        throw new IllegalArgumentException("模板中缺少 " + entryName);
    }

    private Document parse(byte[] xml) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        return factory.newDocumentBuilder().parse(new ByteArrayInputStream(xml));
    }

    private byte[] serialize(Document document) throws Exception {
        Transformer transformer = TransformerFactory.newInstance().newTransformer();
        transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
        transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        transformer.transform(new DOMSource(document), new StreamResult(output));
        return output.toByteArray();
    }

    private byte[] readAll(InputStream input) throws Exception {
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        byte[] buffer = new byte[8192];
        int length;
        while ((length = input.read(buffer)) > 0) {
            output.write(buffer, 0, length);
        }
        return output.toByteArray();
    }

    private Element firstElement(Element parent, String localName) {
        NodeList nodes = parent.getElementsByTagNameNS("*", localName);
        if (nodes.getLength() > 0) return (Element) nodes.item(0);
        if (DRAWING_NS.equals(parent.getNamespaceURI()) && parent.getLocalName() != null
                && localName.equals(parent.getLocalName())) return parent;
        NodeList children = parent.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node instanceof Element) {
                Element found = firstElement((Element) node, localName);
                if (found != null) return found;
            }
        }
        return null;
    }

    private Element firstDirectChild(Element parent, String localName) {
        Node node = parent.getFirstChild();
        while (node != null) {
            if (node instanceof Element && localName.equals(localName(node))) return (Element) node;
            node = node.getNextSibling();
        }
        return null;
    }

    private Element directChild(Element parent, String localName) {
        return firstDirectChild(parent, localName);
    }

    private List<Node> directChildren(Element parent) {
        List<Node> result = new ArrayList<>();
        Node node = parent.getFirstChild();
        while (node != null) {
            result.add(node);
            node = node.getNextSibling();
        }
        return result;
    }

    private String localName(Node node) {
        return node.getLocalName() == null ? node.getNodeName().replaceFirst("^.*:", "") : node.getLocalName();
    }

    public static class DocumentBlock {
    }

    public static class SectionBlock extends DocumentBlock {
        private final String text;

        public SectionBlock(String text) {
            this.text = text;
        }

        public String getText() {
            return text;
        }
    }

    public static class PageBreakBlock extends DocumentBlock {
    }

    public static class ChartBlock extends DocumentBlock {
        private final String title;
        private final byte[] png;
        private final boolean compact;
        private final ImageSize imageSize;

        public ChartBlock(String title, byte[] png) {
            this(title, png, false);
        }

        public ChartBlock(String title, byte[] png, boolean compact) {
            this(title, png, compact, null);
        }

        public ChartBlock(String title, byte[] png, boolean compact, ImageSize imageSize) {
            this.title = title;
            this.png = png;
            this.compact = compact;
            this.imageSize = imageSize;
        }

        public ChartBlock(String title, byte[] png, ImageSize imageSize) {
            this(title, png, false, imageSize);
        }

        public String getTitle() {
            return title;
        }

        public byte[] getPng() {
            return png;
        }

        public boolean isCompact() {
            return compact;
        }

        public ImageSize getImageSize() {
            return imageSize;
        }
    }

    public static class ImageSize {
        private final long width;
        private final long height;

        public ImageSize(long width, long height) {
            this.width = width;
            this.height = height;
        }

        public long getWidth() {
            return width;
        }

        public long getHeight() {
            return height;
        }
    }

    private static class ImageReference {
        private final String relationshipId;
        private final String target;
        private final byte[] image;

        private ImageReference(String relationshipId, String target, byte[] image) {
            this.relationshipId = relationshipId;
            this.target = target;
            this.image = image;
        }

        private String getRelationshipId() {
            return relationshipId;
        }

        private String getTarget() {
            return target;
        }

        private byte[] getImage() {
            return image;
        }
    }

    private static class TemplateParts {
        private Element titleLine;
        private Element subtitleLine;
        private Element titleBlank;
        private Element sectionTemplate;
        private Element sectionBlank;
        private Element lineTitleTemplate;
        private Element lineImageTemplate;
        private Element compactTitleTemplate;
        private Element compactImageTemplate;
        private Element chartBlank;

        private static TemplateParts from(Document document, Element body) {
            TemplateParts parts = new TemplateParts();
            List<Element> paragraphs = directParagraphs(body);
            parts.titleLine = byText(paragraphs, "2026年“十一”假期全省综合运输客流量");
            parts.subtitleLine = byText(paragraphs, "走 势 图");
            parts.sectionTemplate = byText(paragraphs, "总体情况");
            parts.lineTitleTemplate = byText(paragraphs, "2026年“十一”假期全省跨区域人员流动量情况");
            parts.lineImageTemplate = imageAfter(paragraphs, parts.lineTitleTemplate);
            parts.compactTitleTemplate = byText(paragraphs, "“十一”假期各交通运输方式客运量占比情况");
            parts.compactImageTemplate = imageAfter(paragraphs, parts.compactTitleTemplate);
            parts.titleBlank = nextParagraph(paragraphs, parts.subtitleLine);
            parts.sectionBlank = nextParagraph(paragraphs, parts.sectionTemplate);
            parts.chartBlank = afterParagraph(paragraphs, parts.lineImageTemplate);
            if (parts.titleLine == null || parts.subtitleLine == null || parts.sectionTemplate == null
                    || parts.lineTitleTemplate == null || parts.lineImageTemplate == null
                    || parts.compactTitleTemplate == null || parts.compactImageTemplate == null) {
                throw new IllegalArgumentException("走势图模板结构不完整");
            }
            return parts;
        }

        private static List<Element> directParagraphs(Element body) {
            List<Element> result = new ArrayList<>();
            Node node = body.getFirstChild();
            while (node != null) {
                if (node instanceof Element && "p".equals(((Element) node).getLocalName())) {
                    result.add((Element) node);
                }
                node = node.getNextSibling();
            }
            return result;
        }

        private static Element byText(List<Element> paragraphs, String text) {
            for (Element paragraph : paragraphs) {
                if (text.equals(paragraphText(paragraph))) return paragraph;
            }
            return null;
        }

        private static Element imageAfter(List<Element> paragraphs, Element anchor) {
            int index = paragraphs.indexOf(anchor);
            if (index < 0) return null;
            for (int i = index + 1; i < paragraphs.size(); i++) {
                if (firstDescendant(paragraphs.get(i), "blip") != null) return paragraphs.get(i);
            }
            return null;
        }

        private static Element nextParagraph(List<Element> paragraphs, Element anchor) {
            int index = paragraphs.indexOf(anchor);
            return index >= 0 && index + 1 < paragraphs.size() ? paragraphs.get(index + 1) : null;
        }

        private static Element afterParagraph(List<Element> paragraphs, Element anchor) {
            int index = paragraphs.indexOf(anchor);
            return index >= 0 && index + 1 < paragraphs.size() ? paragraphs.get(index + 1) : null;
        }

        private static Element firstDescendant(Element parent, String localName) {
            NodeList nodes = parent.getElementsByTagNameNS("*", localName);
            return nodes.getLength() == 0 ? null : (Element) nodes.item(0);
        }

        private static String paragraphText(Element paragraph) {
            StringBuilder builder = new StringBuilder();
            NodeList nodes = paragraph.getElementsByTagNameNS(WORD_NS, "t");
            for (int i = 0; i < nodes.getLength(); i++) {
                builder.append(nodes.item(i).getTextContent());
            }
            return builder.toString();
        }
    }
}