package de.intevation.flys.client.client.ui;

import com.google.gwt.core.client.GWT;

import com.google.gwt.user.client.rpc.AsyncCallback;

import com.smartgwt.client.util.SC;

import com.smartgwt.client.widgets.Window;
import com.smartgwt.client.widgets.Button;

import com.smartgwt.client.widgets.tree.Tree;
import com.smartgwt.client.widgets.tree.TreeGrid;
import com.smartgwt.client.widgets.tree.TreeNode;

import com.smartgwt.client.types.TreeModelType;

import com.smartgwt.client.widgets.layout.Layout;
import com.smartgwt.client.widgets.layout.VLayout;

import com.smartgwt.client.widgets.events.ClickHandler;
import com.smartgwt.client.widgets.events.ClickEvent;

import com.smartgwt.client.widgets.grid.ListGridRecord;

import com.smartgwt.client.widgets.grid.events.RecordDoubleClickEvent;
import com.smartgwt.client.widgets.grid.events.RecordDoubleClickHandler;

import de.intevation.flys.client.shared.model.Artifact;
import de.intevation.flys.client.shared.model.ArtifactDescription;
import de.intevation.flys.client.shared.model.Data;
import de.intevation.flys.client.shared.model.DataList;
import de.intevation.flys.client.shared.model.DataItem;
import de.intevation.flys.client.shared.model.User;
import de.intevation.flys.client.shared.model.ToLoad;

import de.intevation.flys.client.client.FLYSConstants;
import de.intevation.flys.client.client.Config;

import de.intevation.flys.client.client.services.MetaDataService;
import de.intevation.flys.client.client.services.MetaDataServiceAsync;

import de.intevation.flys.client.shared.model.DataCageTree;
import de.intevation.flys.client.shared.model.DataCageNode;
import de.intevation.flys.client.shared.model.AttrList;

import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.Stack;

public class DatacageWindow
extends      Window
{
    protected MetaDataServiceAsync metaDataService =
        GWT.create(MetaDataService.class);

    protected FLYSConstants messages =
        GWT.create(FLYSConstants.class);


    protected Artifact artifact;
    protected User     user;
    protected String   outs;

    protected TreeGrid treeGrid;
    protected Tree     tree;

    protected Layout layout;

    protected Map<String, ToLoad> toLoad;


    public DatacageWindow(Artifact artifact, User user) {
        this(artifact, user, null);
    }

    public DatacageWindow(Artifact artifact, User user, String outs) {
        this.artifact = artifact;
        this.user     = user;
        this.outs     = outs;

        setWidth(300);
        setHeight(500);

        layout = new VLayout();
        layout.setWidth100();

        addItem(layout);

        tree = new Tree();
        tree.setModelType(TreeModelType.PARENT);
        tree.setNameProperty("name");
        tree.setIdField("id");
        tree.setParentIdField("parent-id");

        treeGrid = new TreeGrid();
        treeGrid.setLoadDataOnDemand(false);
        treeGrid.setWidth100();
        treeGrid.setHeight100();
        treeGrid.setShowRoot(false);

        treeGrid.addRecordDoubleClickHandler(new RecordDoubleClickHandler() {
            @Override
            public void onRecordDoubleClick(RecordDoubleClickEvent event) {
                doubleClickedOnTree(event);
            }
        });

        layout.addMember(treeGrid);

        // TODO: i18n + icon
        Button plusBtn = new Button("+");
        plusBtn.addClickHandler(new ClickHandler() {
            @Override
            public void onClick(ClickEvent event) {
                plusClicked();
            }
        });

        layout.addMember(plusBtn);

        String river =  findRiver();
        // TODO: i18n
        setTitle("Datenkorb: " + river);
        setShowMinimizeButton(false);
        setIsModal(true);
        setShowModalMask(true);
        setCanDragResize(true);

        centerInPage();

        toLoad = new HashMap<String, ToLoad>();

        triggerTreeBuilding();
    }

    public Map<String, ToLoad> toLoad() {
        return toLoad;
    }

    public void plusClicked() {
        if (treeGrid == null) {
            return;
        }

        ListGridRecord [] selection = treeGrid.getSelection();

        if (selection != null) {
            for (ListGridRecord record: selection) {
                if (record instanceof TreeNode) {
                    collectToLoads((TreeNode)record);
                }
            }
        }

        GWT.log(toLoad.toString());

        if (!toLoad.isEmpty()) {
            destroy();
        }
    }

    protected void doubleClickedOnTree(RecordDoubleClickEvent event) {

        TreeNode node = (TreeNode)event.getRecord();
        collectToLoads(node);
        GWT.log(toLoad.toString());
        destroy();
    }

    protected void collectToLoads(TreeNode node) {
        Stack<TreeNode> stack = new Stack<TreeNode>();

        stack.push(node);

        while (!stack.isEmpty()) {
            node = stack.pop();
            String factory = node.getAttribute("factory");
            if (factory != null) { // we need at least a factory
                String ids        = node.getAttribute("ids");
                String artifactId = node.getAttribute("artifact-id");
                String num        = node.getAttribute("num");

                ToLoad tl = toLoad.get(artifactId);
                if (tl == null) {
                    tl = new ToLoad(artifactId);
                }

                tl.add(factory, ids, num);
            }
            TreeNode [] children = tree.getChildren(node);
            if (children != null) {
                for (TreeNode child: children) {
                    stack.push(child);
                }
            }
        }
    }


    protected void triggerTreeBuilding() {
        Config config = Config.getInstance();
        String url    = config.getServerUrl();
        String locale = config.getLocale();

        String artifactId = artifact.getUuid();
        String userId     = user != null ? user.identifier() : null;

        metaDataService.getMetaData(
            url, locale,
            artifactId,
            userId,
            outs,
            new AsyncCallback<DataCageTree>() {
                public void onFailure(Throwable caught) {
                    GWT.log("Could not load meta data.");
                    SC.warn(caught.getMessage());
                }

                public void onSuccess(DataCageTree dcTree) {
                    GWT.log("Successfully loaded meta data.");
                    tree.setData(treeToData(dcTree));
                    treeGrid.setData(tree);
                }
            });
    }

    private static class IdGenerator {
        protected int current;

        public IdGenerator() {
        }

        public IdGenerator(int start) {
            current = start;
        }

        public int next() {
            return current++;
        }
    } // class IdGenerator

    protected static void buildRecursive(
        DataCageNode   node, 
        int            parentId,
        IdGenerator    idGenerator,
        List<TreeNode> nodes
    ) {
        TreeNode tn = new TreeNode();
        int id = idGenerator.next();
        tn.setAttribute("parent-id", parentId);
        tn.setAttribute("id", id);
        // TODO: i18n
        tn.setAttribute("name", node.getName());
        nodes.add(tn);
        AttrList attrs = node.getAttributes();
        if (attrs != null) {
            for (int i = 0, N = attrs.size(); i < N; ++i) {
                String key   = attrs.getKey(i);
                String value = attrs.getValue(i);
                tn.setAttribute(key, value);
            }
        }
        List<DataCageNode> children = node.getChildren();
        if (children != null) {
            for (DataCageNode child: children) {
                buildRecursive(child, id, idGenerator, nodes);
            }
        }
    }


    protected static TreeNode [] treeToData(DataCageTree tree) {
        List<TreeNode> nodes = new ArrayList<TreeNode>();

        DataCageNode root = tree.getRoot();

        IdGenerator idGenerator = new IdGenerator();

        buildRecursive(root, idGenerator.next(), idGenerator, nodes);

        return nodes.toArray(new TreeNode[nodes.size()]);
    }

    protected String findRiver() {

        ArtifactDescription adescr = artifact.getArtifactDescription();
        DataList [] data = adescr.getOldData();

        if (data != null && data.length > 0) {
            for (int i = 0; i < data.length; i++) {
                DataList dl = data[i];
                if (dl.getState().equals("state.winfo.river")) {
                    for (int j = dl.size()-1; j >= 0; --j) {
                        Data d = dl.get(j);
                        DataItem [] di = d.getItems();
                        if (di != null && di.length == 1) {
                           return d.getItems()[0].getStringValue();
                        }
                    }
                }
            }
        }

        return "";
    }
}
// vim:set ts=4 sw=4 si et sta sts=4 fenc=utf8 :