/*
 * Edituri app code
 */

BACKEND_STATE = null;
EDIT_URI = null;


$(document).ready(function() {

    EDIT_URI = {
        URL_REGEXP_FIELDS: ['source_uri', 'backend-type', '--auth-username', '--auth-password', 'server-name', 'server-port', 'server-path', 'querystring'],
        URL_REGEXP: /([^:]+)\:\/\/(?:(?:([^\:]+)(?:\:?:([^@]*))?\@))?(?:([^\/\?\:]+)(?:\:(\d+))?)(?:\/([^\?]*))?(?:\?(.+))?/,
        QUERY_REGEXP: /(?:^|&)([^&=]*)=?([^&]*)/g,

        createFieldset: function(config) {
            var outer = $('<div></div>');
            var label = config.label ? $('<div></div>').addClass('edit-dialog-label ' + (config.labelclass || '')).html(config.label) : null;
            var field;
            if (config.type == 'link') {
                field = config.field === false ? null : 
                    $('<a />').text(config.title)
                    .attr('id', (config.name || ''))
                    .addClass('action-link ' + (config.fieldclass || ''))
                    .attr('href', config.href || '#')
                    .attr('target', config.target || '_blank');

            } else {
                field = config.field === false ? null : 
                    $('<input type="' + (config.type || 'text') + '" name="' + (config.name || '') + '" />')
                    .attr('id', (config.name || ''))
                    .addClass('text ui-widget-content ui-corner-all ' + (config.fieldclass || ''));
                
                if (field && config.value !== undefined)
                    config.attr('value', config.value);
            }

            var checklabel = config.checklabel ? $('<div></div>').addClass('checkbox-label ' + (config.labelclass || '')).html(config.checklabel) : null;

            outer.append(label, field, checklabel);

            var r = {
                outer: outer,
                label: label,
                field: field,
                checklabel: checklabel
            };

            if (config.title)
                for(var k in r)
                    if (r[k])
                        r[k].attr('title', config.title);

            if (config.watermark && field != null)
                field.watermark(config.watermark);

            BACKEND_STATE.fieldset_cleanup.push(outer);

            if (config.after)
                outer.insertAfter(config.after);
            else if (config.before)
                outer.insertBefore(config.before);
            else if (config.append)
                config.append(outer);
            else
                $('#edit-dialog-extensions').append(outer);

            return r;
        },

        validate_input: function(values, validateOptions) {
            if (!BACKEND_STATE.current_state.hideserverandport) {
                if (values['server-name'] == '')
                    return EDIT_URI.validation_error($('server-name'), 'You must fill in the server name');
            } else {
                values['server-name'] = '';
            }

            if (!BACKEND_STATE.current_state.optionalauth) {
                if (values['--auth-username'] == '')
                    return EDIT_URI.validation_error($('server-username'), 'You must fill in a username');
                if (!BACKEND_STATE.current_state.optionalpassword)
                    if (values['--auth-password'] == '')
                        return EDIT_URI.validation_error($('server-password'), 'You must fill in a password');
            }

            if (validateOptions) {
                var validOptions = BACKEND_STATE.module_lookup[values['backend-type']].Options.concat(BACKEND_STATE.extra_options);
                var validOptionsDict = {};
                var names = [];
                for (var n in validOptions) {
                    validOptionsDict[validOptions[n].Name] = validOptions[n];
                    names.push(n.Name);
                    if (n.Aliases != null)
                        for (var i in n.Aliases) {
                            validOptionsDict[i] = n;
                            names.push(i);
                        }
                }

                for(var k in values) {
                    if (k.length > 2 && k.substr(0, 2) == '--') {
                        var opt = validOptionsDict[k.substr(2)];

                        if (!opt) {
                            return EDIT_URI.validation_error($('#server-options'), 'Invalid option: ' + k.substr(2));
                        }

                        if (opt.Deprecated) {
                            alert('Warning', 'The option ' + opt.Name + ' is deprecated :' + opt.DeprecationMessage);
                        }

                        var val = values[k];

                        if (opt.Typename == 'Boolean') {
                            if (!APP_UTIL.isValidBoolOption(val))
                                return EDIT_URI.validation_error($('#server-options'), 'Invalid value for ' + k.substr(2) + ': ' + val + ' is not a valid boolean value');

                        } else if (opt.Typename == 'Password') {

                        } else if (opt.Typename == 'Integer') {
                            if ((parseInt(val) + '') != val) {
                                return EDIT_URI.validation_error($('#server-options'), 'Invalid value for ' + k.substr(2) + ': ' + val + ' is not an integer');
                            }
                        } else if (opt.Typename == 'Size') {
                            //TODO 
                        } else if (opt.Typename == 'Timespan') {
                            //TODO 
                        }

                    }
                }
            }

            return true;
        },

        validation_error: function(el, message) {
            alert(message);
            window.setTimeout( function() { el.focus(); }, 500);
            return false;
        },

        parse_extra_options: function(el, dict) {
            return APP_UTIL.parseOptionStrings(el.val(), dict, function(d, k, v) {
                if (d['--' + k] !== undefined)
                    return EDIT_URI.validation_error(el, 'Duplicate option ' + k);

                return true;
            }) != null;
        },
        build_uri: function(cfg) {
            var url = cfg['backend-type'];
            if (APP_UTIL.parseBoolOption(cfg['--use-ssl'], false))
                url += 's';

            url += '://';
            url += cfg['server-name'];
            if (cfg['server-port'])
                url += ':' + cfg['server-port'];

            if (cfg['server-path'] != '') 
            {
                if(url[url.length - 1] != '/')
                    url += '/';

                url += cfg['server-path'];
            }

            var opts = [];

            if (cfg['--auth-username'] && cfg['--auth-username'] != '')
                opts.push('auth-username=' + encodeURIComponent(cfg['--auth-username']));

            if (cfg['--auth-password'] && cfg['--auth-password'] != '')
                opts.push('auth-password=' + encodeURIComponent(cfg['--auth-password']));

            for(var k in cfg)
                if (k.substr(0, 2) == '--' && k != '--auth-password' && k != '--auth-username' && k != '--use-ssl' && cfg[k] !== false && cfg[k] != '')
                    opts.push(encodeURIComponent(k.substr(2)) + '=' + encodeURIComponent(cfg[k]));

            if (opts.length > 0) {
                url += '?';
                url += opts.join('&');
            }

            return url;
        },

        decode_uri: function(uri) {

            //TODO: Does not like uri's with no server name

            var i = EDIT_URI.URL_REGEXP_FIELDS.length + 1;
            var res = {};

            var m = EDIT_URI.URL_REGEXP.exec(uri);

            // Invalid URI
            if (!m)
                return res;

            while (i--) {
                res[EDIT_URI.URL_REGEXP_FIELDS[i]] = m[i] || "";
            }

            res.querystring.replace(EDIT_URI.QUERY_REGEXP, function(str, key, val) {
                if (key)
                    res['--' + key] = decodeURIComponent(val);
            });

            var scheme = res['backend-type'];

            if (scheme && scheme[scheme.length - 1] == 's' && !APP_DATA.plugins.backend[scheme] && APP_DATA.plugins.backend[scheme.substr(0, scheme.length-1)]) {
                res['backend-type'] = scheme.substr(0, scheme.length-1);
                res['--use-ssl'] = true;
            }

            return res;
        },

        find_scheme: function(uri) {
            if (!uri || uri.length == 0)
                return null;

            uri = uri.trim().toLowerCase();
            var ix = uri.indexOf('://');
            if (ix <= 0) {
                if (BACKEND_STATE.module_lookup['file'])
                    return 'file';
                return BACKEND_STATE.modules[0];
            }

            return (EDIT_URI.decode_uri(uri)['backend-type'] || '').toLowerCase()
        },

        read_form: function(form) {
            var map = EDIT_URI.fill_dict_map;

            var values = APP_UTIL.read_form(form, map);
            if (BACKEND_STATE.current_state.fill_dict_map)
                values = APP_UTIL.read_form(form, BACKEND_STATE.current_state.fill_dict_map, values);

            return values;
        },

        fill_form_map: {
            '--auth-username': 'server-username',
            '--auth-password': 'server-password',
            '--use-ssl': 'server-use-ssl',
            'backend-type': function() {}
        },

        fill_dict_map: {
            'server-username': '--auth-username',
            'server-password': '--auth-password',
            'server-use-ssl': '--use-ssl'
        },

        fill_form: function(form, values) {
            var found = {};

            var map = EDIT_URI.fill_form_map;
            APP_UTIL.fill_form($('#edit-uri-form'), values, map);
            if (BACKEND_STATE.current_state.fill_form_map) {
                map = $.extend(true, {}, map);
                for(var k in map)
                    map[k] = false;

                $.extend(true, map, BACKEND_STATE.current_state.fill_form_map);

                APP_UTIL.fill_form($('#edit-uri-form'), values, map);
            }

            var opttext = '';
            for(var k in values) {
                if (map[k] === undefined && k.indexOf('--') == 0) {
                    opttext += k + '=' + decodeURIComponent(values[k] || '') + '\n';
                }
            }

            form.find('#server-options').val(opttext);
        }
    };

    var resetform = function() {
        $('#server-name').watermark('example.com');
        $('#server-port').watermark('8801');
        $('#server-path').watermark('mybackup');
        $('#server-username').watermark('Username for authentication');
        $('#server-password').watermark('Password for authentication');
        $('#server-options').watermark('Enter connection options here');
        $('#server-username-label').text('Username');
        $('#server-password-label').text('Password');

        if (BACKEND_STATE != null) {
            if (BACKEND_STATE.fieldset_cleanup != null)
                for(var i in BACKEND_STATE.fieldset_cleanup)
                    BACKEND_STATE.fieldset_cleanup[i].remove();

            if (BACKEND_STATE && BACKEND_STATE.current_state && BACKEND_STATE.current_state.cleanup )
                BACKEND_STATE.current_state.cleanup($('#connection-uri-dialog'), $('#edit-dialog-extensions'));        
            BACKEND_STATE.current_state = null;
            BACKEND_STATE.fieldset_cleanup = [];
        }
        $('#edit-dialog-extensions').empty();        
    };

    $('#connection-uri-dialog').on( "dialogclose", function( event, ui ) {
        resetform();
    });

    $('#connection-uri-dialog').on( "dialogopen", function( event, ui ) {
        BACKEND_STATE = {};
        $('#edit-uri-form').each(function(i, e) { e.reset(); });

        APP_DATA.getServerConfig(function(serverdata) {
            var drop = $('#backend-type');
            drop.empty();

            BACKEND_STATE.modules = serverdata['BackendModules'];
            BACKEND_STATE.module_lookup = {};
            BACKEND_STATE.extra_options = [];
            for(var i in serverdata['ConnectionModules'])
                BACKEND_STATE.extra_options = BACKEND_STATE.extra_options.concat(serverdata['ConnectionModules'][i].Options);

            var group_basic = $('<optgroup label="Standard protocols"></optgroup>');
            var group_local = $('<optgroup label="Local storage"></optgroup>');
            var group_prop = $('<optgroup label="Proprietary"></optgroup>');
            var group_others = $('<optgroup label="Others"></optgroup>');

            for (var i = 0; i < BACKEND_STATE.modules.length; i++) {
              BACKEND_STATE.module_lookup[BACKEND_STATE.modules[i].Key] = BACKEND_STATE.modules[i];
            }

            var used = {};

            for(var i in {'ftp':0, 'ssh':0, 'webdav':0}) {
                if (BACKEND_STATE.module_lookup[i]) {
                    used[i] = true;
                    group_basic.append($("<option></option>").attr("value", i).text(BACKEND_STATE.module_lookup[i].DisplayName));
                }
            }

            if (BACKEND_STATE.module_lookup['s3']) {
                used['s3'] = true;
                group_basic.append($("<option></option>").attr("value", 's3').text('S3 compatible'));
            }

            for(var i in {'file':0}) {
                if (BACKEND_STATE.module_lookup[i]) {
                    used[i] = true;
                    group_local.append($("<option></option>").attr("value", i).text(BACKEND_STATE.module_lookup[i].DisplayName));
                }
            }

            for (var i in { 's3': 0, 'azure': 0, 'googledocs': 0, 'onedrive': 0, 'cloudfiles': 0 }) {
                if (BACKEND_STATE.module_lookup[i]) {
                    used[i] = true;
                    group_prop.append($("<option></option>").attr("value", i).text(BACKEND_STATE.module_lookup[i].DisplayName));
                }
            }

            for (var i = 0; i < BACKEND_STATE.modules.length; i++) {
                var k = BACKEND_STATE.modules[i].Key;
                if (!used[k]) {
                    group_others.append($("<option></option>").attr("value", k).text(BACKEND_STATE.module_lookup[k].DisplayName));
                }
            }

            if (group_basic.children().length > 0)
                drop.append(group_basic);
            if (group_local.children().length > 0)
                drop.append(group_local);
            if (group_prop.children().length > 0)
                drop.append(group_prop);
            if (group_others.children().length > 0)
                drop.append(group_others);


            BACKEND_STATE.orig_uri = $('#backup-uri').val();
            BACKEND_STATE.orig_cfg = EDIT_URI.decode_uri(BACKEND_STATE.orig_uri);
            var scheme = BACKEND_STATE.orig_cfg['backend-type'];

            if (scheme == null && (BACKEND_STATE.orig_uri.indexOf('://') < 0 || BACKEND_STATE.orig_uri.indexOf('file://') == 0))
                scheme = 'file';

            if (scheme && APP_DATA.plugins.backend[scheme] && APP_DATA.plugins.backend[scheme].decode_uri) {
                BACKEND_STATE.orig_cfg = APP_DATA.plugins.backend[scheme].decode_uri(BACKEND_STATE.orig_uri);
            }

            BACKEND_STATE.first_setup = true;
            if (scheme && BACKEND_STATE.module_lookup[scheme])
                drop.val(scheme);

            drop.change();
        },
        function() {
            alert('Failed to get server setup...')
        });
    });

    $('#server-use-ssl').change(function() {
        if (BACKEND_STATE.current_state.defaultportssl) {
            if ($('#server-use-ssl').is(':checked')) {
                $('#server-port').watermark(BACKEND_STATE.current_state.defaultportssl + '');            
            } else {
                $('#server-port').watermark(BACKEND_STATE.current_state.defaultport + '');            
            }
        }
    });

    $('#backend-type').change(function() {
        var k = $('#backend-type').val();
        var m = null;
        var hasssl = false;

        var cfg = APP_DATA.plugins.backend[k] || {};

        // Auto-detect for SSL
        if (cfg.hasssl === undefined) {
            var m = BACKEND_STATE.module_lookup[k];
            
            if (m && m.Options)
                for(var i in m.Options)
                    if (m.Options[i].Name == 'use-ssl')
                        cfg.hasssl = true;
        }

        resetform();

        // Simple config changes through properties
        $('#server-use-ssl').toggle(cfg.hasssl == true);
        $('#server-use-ssl-label').toggle(cfg.hasssl == true);

        $('#server-name-and-port-label').toggle(cfg.hideserverandport != true);
        $('#server-name-and-port').toggle(cfg.hideserverandport != true);

        $('#server-port').toggle(cfg.hideport != true);
        $('#server-username-and-password').toggle(cfg.hideusernameandpassword != true);

        if (cfg.usernamelabel)
            $('#server-username-label').text(cfg.usernamelabel + '');
        if (cfg.passwordlabel)
            $('#server-password-label').text(cfg.passwordlabel + '');
        if (cfg.serverandportlabel)
            $('#server-name-and-port-label').text(cfg.serverandportlabel + '');
        if (cfg.serverpathlabel)
            $('#server-path').text(cfg.serverpathlabel + '');
        if (cfg.usernamewatermark)
            $('#server-username-label').watermark(cfg.usernamewatermark + '');
        if (cfg.passwordwatermark)
            $('#server-password-label').watermark(cfg.passwordwatermark + '');
        if (cfg.defaultport)
            $('#server-port').watermark(cfg.defaultport + '');


        BACKEND_STATE.current_state = cfg;

        // Specialized setup
        if (cfg.setup != null)
            cfg.setup($('#connection-uri-dialog'), $('#edit-dialog-extensions'));

        if (!cfg.hasssl)
            $('#server-use-ssl').attr('checked', false);
        $('#server-use-ssl').change();

        if (BACKEND_STATE.first_setup) {
            BACKEND_STATE.first_setup = false;
            if (cfg.fill_form)
                cfg.fill_form($('#edit-uri-form'), BACKEND_STATE.orig_cfg);
            else
                EDIT_URI.fill_form($('#edit-uri-form'), BACKEND_STATE.orig_cfg);
        }
    });

    var validate_and_return_uri = function() {
        var values = EDIT_URI.read_form($('#edit-uri-form'));

        if (!EDIT_URI.parse_extra_options($('#server-options'), values))
            return null;

        if (!BACKEND_STATE.current_state.hasssl && values['--use-ssl'] !== undefined)
            delete values['--use-ssl'];


        if (BACKEND_STATE.current_state.validate)
        {
            if (!BACKEND_STATE.current_state.validate($('#connection-uri-dialog'), values))
                return null;
        } else {
            if (!EDIT_URI.validate_input(values, true))
                return null;
        }

        var uri = null;
        if (BACKEND_STATE.current_state.build_uri) {
            uri = BACKEND_STATE.current_state.build_uri($('#connection-uri-dialog'), values);
        } else {
            uri = EDIT_URI.build_uri(values);
        }

        return uri;
   };

    $('#connection-uri-dialog').dialog({ 
        modal: true, 
        minWidth: 320, 
        width: $('body').width > 600 ? 320 : 600,
        autoOpen: false, 
        closeOnEscape: true,
        buttons: [
            {text: 'Cancel', click: function() { $( this ).dialog( "close" ); } },
            {text: 'Test connection', click: function() {
                var selfbtn = $(this).parent().find('.ui-dialog-buttonpane').find('.ui-button').first().next();

                var hasTriedCreate = false;
                var hasTriedCert = false;

                var testConnection = null;

                var handleError = function(data, success, message) {
                    selfbtn.button('option', 'disabled', false);
                    selfbtn.button('option', 'label', 'Test connection');

                    if (!hasTriedCreate && message == 'missing-folder')
                    {
                        if (confirm('The folder ' + $('#server-path').val() + ' does not exist\nCreate it now?')) {
                            createFolder();
                        }
                    }
                    else if (!hasTriedCert && message.indexOf('incorrect-cert:') == 0)
                    {
                        var hash = message.substr('incorrect-cert:'.length);
                        if (confirm('The server certificate could not be validated.\nDo you want to approve the SSL certificate with the hash: ' + hash + '?' )) {

                            hasTriedCert = true;
                            $('#server-options').val($('#server-options').val() + '--accept-specified-ssl-hash=' + hash);

                            testConnection();
                        }
                    }
                    else
                        alert('Failed to connect: ' + message);
                }

                testConnection = function() {
                    selfbtn.button('option', 'disabled', true);
                    selfbtn.button('option', 'label', 'Testing ...');

                    APP_DATA.callServer({action: 'test-backend', url: uri}, function(data) {
                        selfbtn.button('option', 'disabled', false);
                        selfbtn.button('option', 'label', 'Test connection');
                        alert('Connection worked!');
                    }, handleError);
                };

                var createFolder = function() {
                    hasTriedCreate = true;
                    selfbtn.button('option', 'disabled', true);
                    selfbtn.button('option', 'label', 'Creating folder ...');

                    APP_DATA.callServer(
                        {action: 'create-remote-folder', url: uri}, 
                        testConnection, 
                        handleError
                    );
                };

                var uri = validate_and_return_uri();
                if (uri != null) {
                    testConnection();
                }
            } },
            {text: 'Create URI', click: function() { 

                var uri = validate_and_return_uri();
                if (uri != null) {
                    $( this ).dialog( "close" );
                    $('#backup-uri').val(uri);
                }
            } }
        ]
     });

    $('#server-options-label').click(function() {
        $('#backup-options-dialog').dialog('open');

            var k = $('#backend-type').val();
            var m = BACKEND_STATE.module_lookup[k];
            
            if (m && m.Options) {
            $('#backup-options-dialog').trigger('configure', { Options: m.Options.concat(BACKEND_STATE.extra_options), callback: function(id) {
                $('#backup-options-dialog').dialog('close');

                var txt = $('#server-options').val().trim();
                if (txt.length > 0)
                    txt += '\n';

                var defaultvalue = '';
                for(var o in m.Options)
                    if (m.Options[o].Name == id) {
                        defaultvalue = m.Options[o].DefaultValue;
                        break;
                    }


                txt += '--' + id + '=' + defaultvalue;
                $('#server-options').val('').val(txt);
                $('#server-options').focus();

            }});
        }
    });
});