/*
 * Copyright 2012 Sebastian Annies, Hamburg
 *
 * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
 *
 * 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.googlecode.mp4parser.util;


import com.coremedia.iso.IsoFile;
import com.coremedia.iso.boxes.Box;
import com.coremedia.iso.boxes.ContainerBox;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Path {

    private Path() {
    }

    static Pattern component = Pattern.compile("(....|\\.\\.)(\\[(.*)\\])?");

    public static String createPath(Box box) {
        return createPath(box, "");
    }

    private static String createPath(Box box, String path) {
        if (box instanceof IsoFile) {
            return path;
        } else {
            List<?> boxesOfBoxType = box.getParent().getBoxes(box.getClass());
            int index = boxesOfBoxType.indexOf(box);
            path = String.format("/%s[%d]", box.getType(), index) + path;

            return createPath(box.getParent(), path);
        }
    }

    public static Box getPath(Box box, String path) {
        List<? extends Box> all = getPaths(box, path, true);
        return all.isEmpty() ? null : all.get(0);
    }

    public static List<Box> getPaths(Box box, String path) {
        return getPaths(box, path, false);
    }

    public static List<Box> getPaths(Box box, String path, boolean singleResult) {
        if (path.startsWith("/")) {
            Box isoFile = box;
            while (isoFile.getParent() != null) {
                isoFile = isoFile.getParent();
            }
            assert isoFile instanceof IsoFile : isoFile.getType() + " has no parent";
            return getPaths(isoFile, path.substring(1), singleResult);
        } else if (path.length() == 0) {
            return Collections.singletonList(box);
        } else {
            String later;
            String now;
            if (path.contains("/")) {
                later = path.substring(path.indexOf('/') + 1);
                now = path.substring(0, path.indexOf('/'));
            } else {
                now = path;
                later = "";
            }

            Matcher m = component.matcher(now);
            if (m.matches()) {
                String type = m.group(1);
                if ("..".equals(type)) {
                    return getPaths(box.getParent(), later, singleResult);
                } else {
                    int index = -1;
                    if (m.group(2) != null) {
                        // we have a specific index
                        String indexString = m.group(3);
                        index = Integer.parseInt(indexString);
                    }
                    List<Box> children = new LinkedList<Box>();
                    int currentIndex = 0;
                    for (Box box1 : ((ContainerBox) box).getBoxes()) {
                        if (box1.getType().matches(type)) {
                            if (index == -1 || index == currentIndex) {
                                children.addAll(getPaths(box1, later, singleResult));
                            }
                            currentIndex++;
                        }
                        if (singleResult && !children.isEmpty()) {
                            return children;
                        }
                    }
                    return children;
                }
            } else {
                throw new RuntimeException(now + " is invalid path.");
            }
        }

    }


    public static boolean isContained(Box box, String path) {
        assert path.startsWith("/") : "Absolute path required";
        return getPaths(box, path).contains(box);
    }
}

@@ -785,16 +785,43 @@
 ctions;%0A
+import java.util.Iterator;%0A
 import j
@@ -3347,58 +3347,426 @@
     
-for (Box box1 : ((ContainerBox) box).getBoxes()) %7B
+// I'm suspecting some Dalvik VM to create indexed loops from for-each loops%0A                    // using the iterator instead makes sure that this doesn't happen%0A                    // (and yes - it could be completely useless)%0A                    Iterator%3CBox%3E iterator = ((ContainerBox) box).getBoxes().iterator();%0A                    while (iterator.hasNext()) %7B%0A                        Box box1 = iterator.next();
 %0A   

make sure no java compiler while use indexed loop when simplifying for-each loop (I suspect and)