
"use strict";

function AddToSelectedData(newData) {
    const $flowchart = $('#flowchartworkspace');
    const i = $flowchart.flowchart("getSelectedOperatorId");
    let data = $flowchart.flowchart("getOperatorData", i);

    data.properties = {... data.properties,...newData}
    $flowchart.flowchart("setOperatorData", i, data);
}

function GetSelectedData(id) {
    const $flowchart = $('#flowchartworkspace');

    function extracted(i) {
        let oper = $flowchart.flowchart("getOperatorData", i);
        if (oper == null || oper.properties == null) {
            return {};
        }
        let {inputs, outputs, body, uml, ...data} = oper.properties;
        let links = $flowchart.flowchart("getLinksFrom", i);

        if (data.class) {
            const classes = data.class.replaceAll(' ', '.');
            $(`.${classes} [name][type!='file'][type!="hidden"]`).each((ind, item) => {
                if (!data[item.name]) {
                    data[item.name] = $(item).val();
                } else if (typeof data[item.name] === 'object') {
                    data[item.name] = [...data[item.name], $(item).val()];
                } else {
                    data[item.name] = [data[item.name], $(item).val()];
                }
            });

            const out = $(`.${classes} output`).text();
            if (out > "") {
                data = {... data,...JSON.parse(out)};
            }
        } else {
            const elem = document.createElement("div");
            elem.innerHTML = body;
            const out=$('output', elem).text();
            if (out > "") {
                data = {... data,...JSON.parse(out)};
            }
        }

        for (const link of links) {
            if (data[link.fromConnector]) {
                data[link.fromConnector].push(extracted(link.toOperator));
            } else {
                data[link.fromConnector] = [extracted(link.toOperator)];
            }
            // data[link.fromConnector].connect = link.toConnector;
        }
        return data;
    }

    if (!id) {
        id = $flowchart.flowchart("getSelectedOperatorId");
    }

    return extracted(id);
}

function setProp(val) {
    const $flowchart = $('#flowchartworkspace');
    const i = $flowchart.flowchart("getSelectedOperatorId");
    $flowchart.flowchart("setOperatorData", i, "title", val);
}

function getOperatorData($element, id) {
    var nbInputs = $element.data('nb-inputs');
    var nbOutputs = $element.data('nb-outputs');
    var link = $element.data('nb-link');
    var form = $element.data('nb-form');
    var isFile = $element.data('nb-file');
    var title = $element.text().trim();

    let classes = $element.data('nb-classes');
    if (classes) {
        const parts = classes.split('*');
        if (parts.length > 1) {
            const countClasses = $(`.${parts[1]}`).length;
            classes = `${parts[1]} ${parts[1]}${countClasses + 1}`;
        }
    }

    var data = {
        properties: {
            class: classes,
            title: (link > "") ? `<a href="${link}" rel="noopener noreferrer" target="_blank" onclick="$.post(this.href,{uml:GetSelectedData()}, function(data) {
          fancyOpen(data);
        }); return false;">${title}</a>` : title,
            inputs: {},
            outputs: {},
            body: (form > "") ?
                `<form action="${form.action}" target="${form.target}" onsubmit="$('input[name=uml]', this).val(JSON.stringify(GetSelectedData('${id}')));" method="post">
                <input type="hidden" name="uml">
                <label class="input-label">  Themes of site 
                <ul class="form-field" hx-get="/table/themes/list" hx-trigger="load once" hx-vals='{"value": ".", "count": 0, "order_by": "name"}' hx-target="select[name=themes]">    
                <li class="form-field">   
                <select name="themes">   
                </select>   
                <button class="removeField" type="button" onclick="this.parentNode.remove(); return false;">-</button> </li>     
                </ul> 
                <button class="main-btn" type="button" onclick="p = this.parentNode.firstElementChild; l= p.firstElementChild; p.insertBefore(l.cloneNode(true), null); return false;"> Add new one </button>  
                <h6 class="errorLabel">only digital</h6>
                </label>
<!--<a hx-trigger="click" hx-post="${form.action}"  hx-vals='js:{uml: GetSelectedData()}' hx-confirm="Are you sure to get preview (open new tab)?" target="_blank" hx-target="#flowchart_data"-->
<button type="submit">Preview</a>
</form>` : (isFile) ? `<span class="hiddenInputFile">
<input hx-post="/httpgo/store/put" hx-encoding='multipart/form-data' type='file' hx-trigger="click changed, change" name='blob' hx-vals='{"name": "blob"}' 
accept="text/html" hx-confirm="Upload file?" hx-target="next">
<output></output> 
</span>
</form>` :
                    $element.data('body')
        }
    };

    let i = 0;
    if (typeof nbInputs == "object") {
        for (const nbInput of nbInputs) {
            data.properties.inputs[nbInput] = {
                label: nbInput
            };
        }
    } else if (typeof nbInputs === "string") {
        data.properties.inputs[nbInputs] = {
            label: nbInputs
        };
    } else if (nbInputs === 1) {
        data.properties.inputs['input'] = {
            label: 'Input'
        };
    } else if (nbInputs > 1) {
        for (i = 0; i < nbInputs; i++) {
            data.properties.inputs['input_' + i] = {
                label: 'Input ' + (i + 1)
            };
        }
    }
    // output
    if (typeof nbOutputs == "object") {
        for (const nbOutput of nbOutputs) {
            data.properties.outputs[nbOutput] = {
                label: nbOutput
            };
        }
    } else if (typeof nbOutputs === "string") {
        data.properties.outputs[nbOutputs] = {
            label: nbOutputs
        };
    } else {
        for (i = 0; i < nbOutputs; i++) {
            data.properties.outputs['output_' + i] = {
                label: 'Output ' + (i + 1)
            };
        }
    }

    return data;
}

var isProcess = false
function doFlowChart() {
    if ($.flowchart === undefined) {
        setInterval(doFlowChart, 500);
        return;
    }

    if (isProcess) {
        return;
    }
    isProcess = true;
    var $flowchart = $('#flowchartworkspace');
    var $container = $flowchart.parent();

    console.log('doFlowChart');
    // Apply the plugin on a standard, empty div...
    $flowchart.flowchart({
        data: defaultFlowchartData,
        defaultSelectedLinkColor: '#000055',
        grid: 10,
        multipleLinksOnInput: true,
        multipleLinksOnOutput: true
    });


    //-----------------------------------------
    //--- operator and link properties
    //--- start
    var $operatorProperties = $('#operator_properties');
    $operatorProperties.hide();
    var $linkProperties = $('#link_properties');
    $linkProperties.hide();
    var $operatorTitle = $('#operator_title');
    var $linkColor = $('#link_color');

    $flowchart.flowchart({
        multipleLinksOnInput: true,
        onOperatorSelect: function (operatorId) {
            var selectedOperatorId = $flowchart.flowchart('getSelectedOperatorId');
            if (operatorId === selectedOperatorId) {
                return
            }
            $operatorProperties.show();
            $operatorTitle.val($flowchart.flowchart('getOperatorTitle', operatorId));
            if ($(':focus').length === 0) {
                $operatorTitle.focus();
            }

            return true;
        },
        onOperatorUnselect: function () {
            $operatorProperties.hide();
            return true;
        },
        onLinkSelect: function (linkId) {
            $linkProperties.show();
            $linkColor.val($flowchart.flowchart('getLinkMainColor', linkId));
            return true;
        },
        onLinkUnselect: function () {
            $linkProperties.hide();
            return true;
        },
        onAfterChange:function(el, operatorId, returnHash){
            console.log(`${el}, ${operatorId}, ${returnHash}`);
            return true;
        }
    });

    $operatorTitle.keyup(function () {
        var selectedOperatorId = $flowchart.flowchart('getSelectedOperatorId');
        if (selectedOperatorId != null) {
            $flowchart.flowchart('setOperatorTitle', selectedOperatorId, $operatorTitle.val());
        }
    });

    $linkColor.change(function () {
        var selectedLinkId = $flowchart.flowchart('getSelectedLinkId');
        if (selectedLinkId != null) {
            $flowchart.flowchart('setLinkMainColor', selectedLinkId, $linkColor.val());
        }
    });
    //--- end
    //--- operator and link properties
    //-----------------------------------------

    //-----------------------------------------
    //--- delete operator / link button
    //--- start
    $flowchart.parent().siblings('.delete_selected_button').click(function () {
        $flowchart.flowchart('deleteSelected');
    });
    //--- end
    //--- delete operator / link button
    //-----------------------------------------


    //-----------------------------------------
    //--- create operator button
    //--- start
    var operatorI = 0;
    $flowchart.parent().siblings('.create_operator').click(function () {
        var operatorId = 'created_operator_' + operatorI;
        var operatorData = {
            top: ($flowchart.height() / 2) - 30,
            left: ($flowchart.width() / 2) - 100 + (operatorI * 10),
            properties: {
                title: 'Operator ' + (operatorI + 3),
                inputs: {
                    input_1: {
                        label: 'Input 1',
                    }
                },
                outputs: {
                    output_1: {
                        label: 'Output 1',
                    }
                }
            }
        };

        operatorI++;

        $flowchart.flowchart('createOperator', operatorId, operatorData);

    });
    //--- end
    //--- create operator button
    //-----------------------------------------


    //-----------------------------------------
    //--- draggable operators
    //--- start
    //var operatorId = 0;
    var $draggableOperators = $('.draggable_operator');
    $draggableOperators.draggable({
        cursor: "move",
        opacity: 0.7,

        // helper: 'clone',
        appendTo: 'body',
        zIndex: 1000,
        drag: function () {
            var $this = $(this);
            let classes = $this.data('nb-classes');
            const countClasses = $(`.${classes}`, $flowchart).length;
            if (countClasses > 0) {
                alert('cannot create unique class at second time');
                return false;
            }

            return true;
        },
        helper: function (e) {
            var $this = $(this);
            var data = getOperatorData($this, true);
            return $flowchart.flowchart('getOperatorElement', data);
        },
        stop: function (e, ui) {
            var $this = $(this);
            var elOffset = ui.offset;
            var containerOffset = $container.offset();
            if (elOffset.left > containerOffset.left &&
                elOffset.top > containerOffset.top &&
                elOffset.left < containerOffset.left + $container.width() &&
                elOffset.top < containerOffset.top + $container.height()) {

                var flowchartOffset = $flowchart.offset();

                var relativeLeft = elOffset.left - flowchartOffset.left;
                var relativeTop = elOffset.top - flowchartOffset.top;

                var positionRatio = $flowchart.flowchart('getPositionRatio');
                relativeLeft /= positionRatio;
                relativeTop /= positionRatio;

                var id = $this.data('nb-id');
                var data = getOperatorData($this, id);
                if (!data) {
                    return false;
                }
                data.left = relativeLeft;
                data.top = relativeTop;
                if (id) {
                    $flowchart.flowchart('createOperator', id, data);
                } else {
                    id = $flowchart.flowchart('addOperator', data);
                }

                console.log(id);
                // let el = $flowchart.flowchart('getOperatorElement', data);
                // console.log(el);
                // activate htmx triggers
                $('.flowchart-operator-body [hx-trigger]').each(function (ind, item) {
                    htmx.process(item);
                });
            }
        }
    });
    //--- end
    //--- draggable operators
    //-----------------------------------------


    //-----------------------------------------
    //--- save and load
    //--- start
    function Flow2Text() {
        var data = $flowchart.flowchart('getData');
        $('#flowchart_data').load('/code/json', {src: JSON.stringify(data)});
    }

    $('#get_data').click(Flow2Text);

    function Text2Flow() {
        var data = JSON.parse($('#flowchart_data').val());
        $flowchart.flowchart('setData', data);
    }

    $('#set_data').click(Text2Flow);

    /*global localStorage*/
    function SaveToLocalStorage() {
        if (typeof localStorage !== 'object') {
            alert('local storage not available');
            return;
        }
        var data = JSON.stringify($flowchart.flowchart('getData'));
        $('#flowchart_data').val(data);
        localStorage.setItem("stgLocalFlowChart", data);
    }

    $('#save_local').click(SaveToLocalStorage);

    function LoadFromLocalStorage() {
        if (typeof localStorage !== 'object') {
            alert('local storage not available');
            return;
        }
        var s = localStorage.getItem("stgLocalFlowChart");
        if (s != null) {
            $('#flowchart_data').val(s);
            let data = JSON.parse(s);
            $flowchart.flowchart('setData', data);
            console.log(data);
        } else {
            alert('local storage empty');
        }
    }

    $('#load_local').click(LoadFromLocalStorage);
    //--- end
    //--- save and load
    //-----------------------------------------


}

var defaultFlowchartData = {
    operators: {
        apis: {
            top: 20,
            left: 20,
            properties: {
                title: 'APIS',
                inputs: {
                    path: {
                        label: '/search/list'
                    }
                },
                outputs: {
                    handler: {
                        label: 'HandlerSearchList',
                    }
                }
            }
        },
        DB: {
            top: 80,
            left: 300,
            properties: {
                title: 'DB',
                inputs: {
                    table: {
                        label: 'Projects',
                    }
                },
                outputs: {
                    oper: {
                        label: 'SelectAll',
                    },
                }
            }
        },
    },
    links: {
        link_1: {
            fromOperator: 'apis',
            fromConnector: 'handler',
            toOperator: 'DB',
            toConnector: 'table',
        },
    }
};

