$ = jQuery


Position =
    getName: (position) ->
        return Position.strings[position - 1]

    nameToIndex: (name) ->
        for i in [1..Position.strings.length]
            if Position.strings[i - 1] == name
                return i
        return 0

Position.BEFORE = 1
Position.AFTER = 2
Position.INSIDE = 3
Position.NONE = 4

Position.strings = ['before', 'after', 'inside', 'none']

class Node
    constructor: (o, is_root=false, node_class=Node) ->
        @name = ''

        @setData(o)

        @children = []
        @parent = null

        if is_root
            @id_mapping = {}
            @tree = this
            @node_class = node_class

    setData: (o) ->
        ###
        Set the data of this node.

        setData(string): set the name of the node
        setdata(object): set attributes of the node

        Examples:
            setdata('node1')

            setData({ name: 'node1', id: 1});

            setData({ name: 'node2', id: 2, color: 'green'});

        * This is an internal function; it is not in the docs
        * Does not remove existing node values
        ###
        setName = (name) =>
            if name != null
                @name = name

        if typeof o != 'object'
            setName(o)
        else
            for key, value of o
                if key == 'label'
                    # You can use the 'label' key instead of 'name'; this is a legacy feature
                    setName(value)
                else if key != 'children'
                    # You can't update the children using this function
                    @[key] = value

        return null

    # Init Node from data without making it the root of the tree
    initFromData: (data) ->
        addNode = (node_data) =>
            @setData(node_data)

            if node_data.children
                addChildren(node_data.children)

        addChildren = (children_data) =>
            for child in children_data
                node = new @tree.node_class('')
                node.initFromData(child)
                @addChild(node)
            return null

        addNode(data)
        return null

    ###
    Create tree from data.

    Structure of data is:
    [
        {
            label: 'node1',
            children: [
                { label: 'child1' },
                { label: 'child2' }
            ]
        },
        {
            label: 'node2'
        }
    ]
    ###
    loadFromData: (data) ->
        @removeChildren()

        for o in data
            node = new @tree.node_class(o)
            @addChild(node)

            if typeof o == 'object' and o.children
                node.loadFromData(o.children)

        return null

    ###
    Add child.

    tree.addChild(
        new Node('child1')
    );
    ###
    addChild: (node) ->
        @children.push(node)
        node._setParent(this)

    ###
    Add child at position. Index starts at 0.

    tree.addChildAtPosition(
        new Node('abc'),
        1
    );
    ###
    addChildAtPosition: (node, index) ->
        @children.splice(index, 0, node)
        node._setParent(this)

    _setParent: (parent) ->
        @parent = parent
        @tree = parent.tree
        @tree.addNodeToIndex(this)

    ###
    Remove child. This also removes the children of the node.

    tree.removeChild(tree.children[0]);
    ###
    removeChild: (node) ->
        # remove children from the index
        node.removeChildren()

        @_removeChild(node)

    _removeChild: (node) ->
        @children.splice(
            @getChildIndex(node),
            1
        )
        @tree.removeNodeFromIndex(node)

    ###
    Get child index.

    var index = getChildIndex(node);
    ###
    getChildIndex: (node) ->
        return $.inArray(node, @children)

    ###
    Does the tree have children?

    if (tree.hasChildren()) {
        //
    }
    ###
    hasChildren: ->
        return @children.length != 0

    isFolder: ->
        return @hasChildren() or @load_on_demand

    ###
    Iterate over all the nodes in the tree.

    Calls callback with (node, level).

    The callback must return true to continue the iteration on current node.

    tree.iterate(
        function(node, level) {
           console.log(node.name);

           // stop iteration after level 2
           return (level <= 2);
        }
    );

    ###
    iterate: (callback) ->
        _iterate = (node, level) ->
            if node.children
                for child in node.children
                    result = callback(child, level)

                    if result and child.hasChildren()
                        _iterate(child, level + 1)
                return null

        _iterate(this, 0)
        return null

    ###
    Move node relative to another node.

    Argument position: Position.BEFORE, Position.AFTER or Position.Inside

    // move node1 after node2
    tree.moveNode(node1, node2, Position.AFTER);
    ###
    moveNode: (moved_node, target_node, position) ->
        if moved_node.isParentOf(target_node)
            # Node is parent of target node. This is an illegal move
            return

        moved_node.parent._removeChild(moved_node)
        if position == Position.AFTER
            target_node.parent.addChildAtPosition(
                moved_node,
                target_node.parent.getChildIndex(target_node) + 1
            )
        else if position == Position.BEFORE
            target_node.parent.addChildAtPosition(
                moved_node,
                target_node.parent.getChildIndex(target_node)
            )
        else if position == Position.INSIDE
            # move inside as first child
            target_node.addChildAtPosition(moved_node, 0)

    ###
    Get the tree as data.
    ###
    getData: (include_parent=false) ->
        getDataFromNodes = (nodes) ->
            data = []

            for node in nodes
                tmp_node = {}

                for k, v of node
                    if (
                        k not in ['parent', 'children', 'element', 'tree'] and
                        Object.prototype.hasOwnProperty.call(node, k)
                    )
                        tmp_node[k] = v

                if node.hasChildren()
                    tmp_node.children = getDataFromNodes(node.children)

                data.push(tmp_node)

            return data

        if include_parent
            return getDataFromNodes([this])
        else
            return getDataFromNodes(@children)

    getNodeByName: (name) ->
        return @getNodeByCallback(
            (node) -> (node.name == name)
        )

    getNodeByCallback: (callback) ->
        result = null

        @iterate(
            (node) ->
                if callback(node)
                    result = node
                    return false
                else
                    return true
        )

        return result


    addAfter: (node_info) ->
        if not @parent
            return null
        else
            node = new @tree.node_class(node_info)

            child_index = @parent.getChildIndex(this)
            @parent.addChildAtPosition(node, child_index + 1)

            if typeof node_info == 'object' and node_info.children and node_info.children.length
                node.loadFromData(node_info.children)

            return node

    addBefore: (node_info) ->
        if not @parent
            return null
        else
            node = new @tree.node_class(node_info)

            child_index = @parent.getChildIndex(this)
            @parent.addChildAtPosition(node, child_index)

            if typeof node_info == 'object' and node_info.children and node_info.children.length
                node.loadFromData(node_info.children)

            return node

    addParent: (node_info) ->
        if not @parent
            return null
        else
            new_parent = new @tree.node_class(node_info)
            new_parent._setParent(@tree)
            original_parent = @parent

            for child in original_parent.children
                new_parent.addChild(child)

            original_parent.children = []
            original_parent.addChild(new_parent)
            return new_parent

    remove: ->
        if @parent
            @parent.removeChild(this)
            @parent = null

    append: (node_info) ->
        node = new @tree.node_class(node_info)
        @addChild(node)

        if typeof node_info == 'object' and node_info.children and node_info.children.length
            node.loadFromData(node_info.children)

        return node

    prepend: (node_info) ->
        node = new @tree.node_class(node_info)
        @addChildAtPosition(node, 0)

        if typeof node_info == 'object' and node_info.children and node_info.children.length
            node.loadFromData(node_info.children)

        return node

    isParentOf: (node) ->
        parent = node.parent

        while parent
            if parent == this
                return true

            parent = parent.parent

        return false

    getLevel: ->
        level = 0
        node = this

        while node.parent
            level += 1
            node = node.parent

        return level

    getNodeById: (node_id) ->
        return @id_mapping[node_id]

    addNodeToIndex: (node) ->
        if node.id?
            @id_mapping[node.id] = node

    removeNodeFromIndex: (node) ->
        if node.id?
            delete @id_mapping[node.id]

    removeChildren: ->
        @iterate(
            (child) =>
                @tree.removeNodeFromIndex(child)
                return true
        )

        @children = []

    getPreviousSibling: ->
        if not @parent
            return null
        else
            previous_index = @parent.getChildIndex(this) - 1
            if previous_index >= 0
                return @parent.children[previous_index]
            else
                return null

    getNextSibling: ->
        if not @parent
            return null
        else
            next_index = @parent.getChildIndex(this) + 1
            if next_index < @parent.children.length
                return @parent.children[next_index]
            else
                return null

    getNodesByProperty: (key, value) ->
        return @filter(
            (node) ->
                return node[key] == value
        )

    filter: (f) ->
        result = []

        @iterate(
            (node) ->
                if f(node)
                    result.push(node)

                return true
        )

        return result

    getNextNode: (include_children=true) ->
        if include_children and @hasChildren() and @is_open
            # First child
            return @children[0]
        else
            if not @parent
                return null
            else
                next_sibling = @getNextSibling()
                if next_sibling
                    # Next sibling
                    return next_sibling
                else
                    # Next node of parent
                    return @parent.getNextNode(false)

    getPreviousNode: ->
        if not @parent
            return null
        else
            previous_sibling = @getPreviousSibling()
            if previous_sibling
                if not previous_sibling.hasChildren() or not previous_sibling.is_open
                    # Previous sibling
                    return previous_sibling
                else
                    # Last child of previous sibling
                    return previous_sibling.getLastChild()
            else
                return @getParent()

    getParent: ->
        # Return parent except if it is the root node
        if not @parent
            return null
        else if not @parent.parent
            # Root node -> null
            return null
        else
            return @parent

    getLastChild: ->
        if not @hasChildren()
            return null
        else
            last_child = @children[@children.length - 1]
            if not last_child.hasChildren() or not last_child.is_open
                return last_child
            else
                return last_child.getLastChild()


module.exports =
    Node: Node
    Position: Position