/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and Others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Hisashi MIYASHITA - initial API and implementation
 *******************************************************************************/
package org.eclipse.actf.ai.fennec.impl;

import org.eclipse.actf.ai.fennec.IFennecEntry;
import org.eclipse.actf.ai.fennec.IFennecService;
import org.eclipse.actf.ai.fennec.FennecException;
import org.eclipse.actf.ai.fennec.FennecInterruptedException;
import org.eclipse.actf.ai.fennec.treemanager.IAccessKeyList;
import org.eclipse.actf.ai.fennec.treemanager.ISoundControl;
import org.eclipse.actf.ai.fennec.treemanager.ITreeItem;
import org.eclipse.actf.ai.fennec.treemanager.ITreeManager;
import org.eclipse.actf.ai.fennec.treemanager.IVideoControl;
import org.eclipse.actf.ai.fennec.treemanager.TreeManagerException;
import org.eclipse.actf.ai.query.IQuery;
import org.eclipse.actf.ai.query.QueryService;
import org.eclipse.actf.model.dom.dombycom.AnalyzedResult;
import org.eclipse.actf.model.dom.dombycom.IDocumentEx;
import org.eclipse.actf.model.dom.dombycom.IFlashNode;
import org.eclipse.actf.model.dom.dombycom.INodeEx;
import org.eclipse.actf.util.vocab.IProposition;
import org.eclipse.actf.util.vocab.Vocabulary;
import org.w3c.dom.Element;


public class FennecServiceImpl implements IFennecService {
    private FennecMetadata rootMetadata;

    private int status;

    private TreeItemFennec lastItem;

    private IDocumentEx document;

    private Element root;

    private AnalyzedResult analyzedResult;

    Element getDocumentElement() {
        return root;
    }

    private void initDefaultMetadata() {
        FennecMode rootMode = new FennecMode(FennecMode.TYPE_SIMPLE);
        FennecMode nextMode = new FennecMode(FennecMode.TYPE_ATTACH, FennecMode.TRIGGER_ALWAYS, true, false, false);
        // /HTML/FRAMESET/FRAME/HTML/BODY
        //IQuery q = QueryService.createFromXPath("/HTML/BODY|/HTML/FRAMESET//FRAME/HTML/BODY");
        //IQuery q = QueryService.createFromXPath("//HTML/BODY");
        IQuery q = QueryService.createFromXPath("/HTML");
        FennecMetadata[] mds = new FennecMetadata[1];
        mds[0] = FennecRecombinantMetadata.newAttach(this, q, rootMode, nextMode, null);
        rootMetadata = new FennecGroupMetadata(this, null, rootMode, mds);
    }

    public FennecServiceImpl(IFennecEntry entry, IDocumentEx document) throws FennecException {
        this.document = document;
        this.root = document.getDocumentElement();
        try {
            FennecDOMReader reader = new FennecDOMReader(this);
            rootMetadata = reader.parse(entry);
            this.status = UNINIT;
        } catch (Exception e) {
            throw new FennecException("Failed to load Fennec data.", e);
        }
    }

    public FennecServiceImpl(IDocumentEx document) {
        this.document = document;
        this.root = document.getDocumentElement();
        initDefaultMetadata();
    }

    public int getStatus() {
        return status;
    }

    public int analyze() throws FennecException {
        analyzedResult = new AnalyzedResult();
        if (root instanceof INodeEx) {
            cachedVideoControl = null;
            cachedSoundControl = null;
            analyzedResult = ((INodeEx) root).analyze(analyzedResult);
        }
        return ITreeManager.NOACTION;
    }

    private ISoundControl cachedSoundControl;

    private IVideoControl cachedVideoControl;

    private IAccessKeyList cachedAccessKeyList;
    
    private IFlashNode[] cachedFlashTopNodes;

    public int initialize() throws FennecException {
        if (analyzedResult == null) {
            analyze();
        }
        lastItem = rootMetadata.buildRootItem();
        if (lastItem == null) {
            throw new FennecException("Failed to initialize", null);
        }
        status = NORMAL;
        return ITreeManager.MOVED;
    }

    public ITreeItem getLastTreeItem() {
        return lastItem;
    }

    private int update(ITreeItem target, int trigger) throws FennecException {
        TreeItemFennec targetItem = (TreeItemFennec) target;
        if (targetItem.getParent() == null) {
            return initialize();
        } else {
            targetItem = targetItem.expand(trigger);
            if (targetItem == null) {
                return ITreeManager.NOACTION;
            }
        }
        if (targetItem == null) {
            status = UNINIT;
            throw new FennecInterruptedException("Lost my way"); // $ NON-NLS-1
        }
        lastItem = targetItem;
        return ITreeManager.MOVED;
    }

    public int moveUpdate(ITreeItem target) throws FennecException {
        return update(target, FennecMode.TRIGGER_MOVE);
    }

    public int moveUpdate(ITreeItem target, boolean update) throws FennecException {
        if (update) {
            return update(target, FennecMode.TRIGGER_MOVE);
        } else {
            return update(target, FennecMode.TRIGGER_MOVE | FennecMode.TRIGGER_WITHOUTCHANGE);
        }
    }

    public int clickUpdate(ITreeItem target) throws FennecException {
        return update(target, FennecMode.TRIGGER_CLICK) | ITreeManager.CLICKED;
    }

    private int searchForwardChildren(int idx, TreeItemFennec item, IProposition proposition) throws FennecException {
        int st;
        item = item.expandChildItems(FennecMode.TRIGGER_KEEP);
        ITreeItem[] childItems = item.getChildItems();
        for (int i = idx; i < childItems.length; i++) {
            TreeItemFennec cItem = (TreeItemFennec) childItems[i];
            if (proposition.eval(cItem)) {
                return moveUpdate(cItem) | ITreeManager.FOUND;
            }
            st = searchForwardChildren(0, cItem, proposition);
            if ((st & ITreeManager.FOUND) != 0)
                return st;
        }
        return ITreeManager.NOACTION;
    }

    private int searchForwardInternal(int idx, TreeItemFennec item, IProposition proposition) throws FennecException {
        int st = searchForwardChildren(idx, item, proposition);
        if ((st & ITreeManager.FOUND) != 0)
            return st;
        TreeItemFennec pItem = (TreeItemFennec) item.getParent();
        if (pItem == null)
            return ITreeManager.NOACTION;
        st = searchForwardInternal(item.getNth() + 1, pItem, proposition);
        if ((st & ITreeManager.FOUND) != 0)
            return st;

        return ITreeManager.NOACTION;
    }

    public ITreeItem[] getSiblings() throws TreeManagerException {
        ITreeItem parent = lastItem.getParent();
        if (parent == null) {
            ITreeItem[] itas = new ITreeItem[1];
            itas[0] = lastItem;
            return itas;
        }
        return parent.getChildItems();
    }

    public int searchForward(IProposition proposition) throws FennecException {
        return searchForwardInternal(0, lastItem, proposition);
    }

    private int searchBackwardInternal(boolean first, TreeItemFennec item, IProposition proposition) throws FennecException {
        TreeItemFennec pItem = (TreeItemFennec) item.getParent();
        if (pItem == null)
            return ITreeManager.NOACTION;
        int nth = item.getNth() - 1;
        if (nth < 0) {
            if (proposition.eval(pItem)) {
                return moveUpdate(pItem) | ITreeManager.FOUND;
            }
            return searchBackwardInternal(false, pItem, proposition);
        }
        if (first) {
            pItem = pItem.expandChildItems(FennecMode.TRIGGER_KEEP);
        }
        ITreeItem[] siblings = pItem.getChildItems();
        if (nth >= siblings.length) {
            nth = siblings.length - 1;
        }
        item = (TreeItemFennec) siblings[nth];

        while (true) {
            item = item.expandChildItems(FennecMode.TRIGGER_KEEP);
            ITreeItem[] childItems = item.getChildItems();
            if (childItems.length == 0)
                break;
            item = (TreeItemFennec) childItems[childItems.length - 1];
        }
        if (proposition.eval(item)) {
            return moveUpdate(item) | ITreeManager.FOUND;
        }
        return searchBackwardInternal(false, item, proposition);
    }

    public int searchBackward(IProposition predicate) throws FennecException {
        return searchBackwardInternal(true, lastItem, predicate);
    }

    public ISoundControl getSoundControl() {
        if (cachedSoundControl == null) {
            cachedSoundControl = TreeItemSoundControl.newTreeItemSoundControl(analyzedResult);
        }
        return cachedSoundControl;
    }

    public IVideoControl getVideoControl() {
        if (cachedVideoControl == null) {
            cachedVideoControl = TreeItemVideoControl.newTreeItemVideoControl(analyzedResult, this);
        }
        return cachedVideoControl;
    }
    
    public IAccessKeyList getAccessKeyList() {
        if (cachedAccessKeyList == null) {
            cachedAccessKeyList = TreeItemAccessKeyList.newAccessKeyList(analyzedResult);
        }
        return cachedAccessKeyList;
    }

    public IFlashNode[] getFlashTopNodes() {
        if (cachedFlashTopNodes == null) {
            cachedFlashTopNodes = analyzedResult.getFlashTopNodes();
        }
        return cachedFlashTopNodes;
    }

    private void expandWholeTreeInternal(TreeItemFennec item) throws FennecException {
        item = item.expandChildItems(FennecMode.TRIGGER_KEEP);
        ITreeItem[] childItems = item.getChildItems();
        for (int i = 0; i < childItems.length; i++) {
            expandWholeTreeInternal((TreeItemFennec) childItems[i]);
        }
    }

    private int skipToNode(Element e) throws FennecException {
        initialize();
        return searchForward(Vocabulary.nodeLocation(e, false));
    }

    public int skipToAnchor(String target) throws FennecException {
        Element el = document.getTargetElement(target);
        if (el != null)
            return skipToNode(el);
        return ITreeManager.NOACTION;
    }

    public ITreeItem expandWholeTree() throws FennecException {
        initialize();
        if (lastItem instanceof TreeItemFennec) {
            expandWholeTreeInternal((TreeItemFennec) lastItem);
        }
        return lastItem;
    }

}