/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.eclipse.org/org/documents/epl-v10.php
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.ide.eclipse.adt.internal.editors;

import static org.eclipse.wst.xml.core.internal.regions.DOMRegionContext.XML_EMPTY_TAG_CLOSE;
import static org.eclipse.wst.xml.core.internal.regions.DOMRegionContext.XML_END_TAG_OPEN;
import static org.eclipse.wst.xml.core.internal.regions.DOMRegionContext.XML_TAG_CLOSE;
import static org.eclipse.wst.xml.core.internal.regions.DOMRegionContext.XML_TAG_NAME;
import static org.eclipse.wst.xml.core.internal.regions.DOMRegionContext.XML_TAG_OPEN;

import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
import org.eclipse.wst.xml.ui.internal.text.XMLDocumentRegionEdgeMatcher;

/**
 * Custom version of the character matcher for XML files which adds the ability to
 * jump between open and close tags in the XML file.
 */
@SuppressWarnings("restriction")
public class AndroidXmlCharacterMatcher extends XMLDocumentRegionEdgeMatcher {
    public AndroidXmlCharacterMatcher() {
    }

    @Override
    public IRegion match(IDocument doc, int offset) {
        if (offset < 0 || offset >= doc.getLength()) {
            return null;
        }

        IRegion match = findOppositeTag(doc, offset);
        if (match != null) {
            return match;
        }

        return super.match(doc, offset);
    }

    private IRegion findOppositeTag(IDocument document, int offset) {
        if (!(document instanceof IStructuredDocument)) {
            return null;
        }
        IStructuredDocument doc = (IStructuredDocument) document;

        IStructuredDocumentRegion region = doc.getRegionAtCharacterOffset(offset);
        if (region == null) {
            return null;
        }

        ITextRegion subRegion = region.getRegionAtCharacterOffset(offset);
        if (subRegion == null) {
            return null;
        }
        ITextRegionList subRegions = region.getRegions();
        int index = subRegions.indexOf(subRegion);

        String type = subRegion.getType();
        boolean isOpenTag = false;
        boolean isCloseTag = false;

        if (type.equals(XML_TAG_OPEN)) {
            isOpenTag = true;
        } else if (type.equals(XML_END_TAG_OPEN)) {
            isCloseTag = true;
        } else if (!(type.equals(XML_TAG_CLOSE) || type.equals(XML_TAG_NAME)) &&
                (subRegion.getStart() + region.getStartOffset() == offset)) {
            // Look to the left one character; we may have the case where you're
            // pointing to the right of a tag, e.g.
            //     <foo>^text
            offset--;
            region = doc.getRegionAtCharacterOffset(offset);
            if (region == null) {
                return null;
            }
            subRegion = region.getRegionAtCharacterOffset(offset);
            if (subRegion == null) {
                return null;
            }
            type = subRegion.getType();

            subRegions = region.getRegions();
            index = subRegions.indexOf(subRegion);
        }

        if (type.equals(XML_TAG_CLOSE) || type.equals(XML_TAG_NAME)) {
            for (int i = index; i >= 0; i--) {
                subRegion = subRegions.get(i);
                type = subRegion.getType();
                if (type.equals(XML_TAG_OPEN)) {
                    isOpenTag = true;
                    break;
                } else if (type.equals(XML_END_TAG_OPEN)) {
                    isCloseTag = true;
                    break;
                }
            }
        }

        if (isOpenTag) {
            // Find closing tag
            int target = findTagForwards(doc, subRegion.getStart() + region.getStartOffset(), 0);
            // Note - there is no point in looking up the whole region for the matching
            // tag, because even if you pass a length greater than 1 here, the paint highlighter
            // will only highlight a single character -- the *last* character of the region,
            // not the whole region itself.
            return new Region(target, 1);
        } else if (isCloseTag) {
            // Find open tag
            int target = findTagBackwards(doc, subRegion.getStart() + region.getStartOffset(), -1);
            return new Region(target, 1);
        }

        return null;
    }

    /**
     * Finds the corresponding open tag by searching backwards until the tag balance
     * reaches a given target.
     *
     * @param doc the document
     * @param offset the ending offset (where the search begins searching backwards from)
     * @param targetTagBalance the balance to end the search at
     * @return the offset of the beginning of the open tag
     */
    public static int findTagBackwards(IStructuredDocument doc, int offset, int targetTagBalance) {
        // Balance of open and closing tags
        int tagBalance = 0;
        // Balance of open and closing brackets
        IStructuredDocumentRegion region = doc.getRegionAtCharacterOffset(offset);
        if (region != null) {
            boolean inEmptyTag = true;

            while (region != null) {
                int regionStart = region.getStartOffset();
                ITextRegionList subRegions = region.getRegions();
                for (int i = subRegions.size() - 1; i >= 0; i--) {
                    ITextRegion subRegion = subRegions.get(i);
                    int subRegionStart = regionStart + subRegion.getStart();
                    if (subRegionStart >= offset) {
                        continue;
                    }
                    String type = subRegion.getType();

                    // Iterate backwards and keep track of the tag balance such that
                    // we can find the corresponding opening tag

                    if (XML_TAG_OPEN.equals(type)) {
                        if (!inEmptyTag) {
                            tagBalance--;
                        }
                        if (tagBalance == targetTagBalance) {
                            return subRegionStart;
                        }
                    } else if (XML_END_TAG_OPEN.equals(type)) {
                        tagBalance++;
                    } else if (XML_EMPTY_TAG_CLOSE.equals(type)) {
                        inEmptyTag = true;
                    } else if (XML_TAG_CLOSE.equals(type)) {
                        inEmptyTag = false;
                    }
                }

                region = region.getPrevious();
            }
        }

        return -1;
    }

    public static int findTagForwards(IStructuredDocument doc, int start, int targetTagBalance) {
        int tagBalance = 0;
        IStructuredDocumentRegion region = doc.getRegionAtCharacterOffset(start);

        if (region != null) {
            while (region != null) {
                int regionStart = region.getStartOffset();
                ITextRegionList subRegions = region.getRegions();
                for (int i = 0, n = subRegions.size(); i < n; i++) {
                    ITextRegion subRegion = subRegions.get(i);
                    int subRegionStart = regionStart + subRegion.getStart();
                    int subRegionEnd = regionStart + subRegion.getEnd();
                    if (subRegionEnd < start) {
                        continue;
                    }
                    String type = subRegion.getType();

                    if (XML_TAG_OPEN.equals(type)) {
                        tagBalance++;
                    } else if (XML_END_TAG_OPEN.equals(type)) {
                        tagBalance--;
                        if (tagBalance == targetTagBalance) {
                            return subRegionStart;
                        }
                    } else if (XML_EMPTY_TAG_CLOSE.equals(type)) {
                        tagBalance--;
                        if (tagBalance == targetTagBalance) {
                            // We don't jump to matching tags within a self-closed tag
                            return -1;
                        }
                    }
                }

                region = region.getNext();
            }
        }

        return -1;
    }
}
