/// <reference path="ext-base.js" />
/// <reference path="ext-all.js" />

var requestId = Ext.getUrlParam('id');
if (requestId == undefined)
    requestId = getCookie("guestRequestId");
var updateReport = function() { };
var onCompetitorAdd = function() { };
var onSavedReportAdd = function() { };
var onReportReady = function() { };
var reportTabs = new Array();
var defaultPageSize = 20;
var adRenderer = function() { };
var seRenderer = function() { };
var posRenderer = function() { };
var organicPosRenderer = function() { };
var isKeywordReport;
var reportObjectName;

var taskRunnerMember;
var searchingMask;

var isOnePageReport = fullReport;

var updateReportTask = {
    run: function() { updateReport(); },
    interval: 10000 //10 seconds
};

function findGridComponent(items) {
    for (var i = 0; i < items.length; i++) {

        if (items[i].store) {
            return items[i];
        }
    }

    return null;
}

function AddGridToPdf(reportInfo, grid, title, baseParams) {
    var tableColumns = [];

    for (var i = 0; i < grid.colModel.config.length; i++) {
        var column = grid.colModel.config[i];

        if (column.hidden || column.dataIndex == '') {
            continue;
        }

        tableColumns.push(column.dataIndex + ',' + column.header + ',' + column.width);
    }

    var columnInfo = tableColumns.join(';');

    var sortInfo = '';
    if (grid.store.sortInfo != null) {
        sortInfo = grid.store.sortInfo.field + ' ' + grid.store.sortInfo.direction;
    }

    var tableInfo = title + ',' + sortInfo;

    reportInfo.push(tableInfo + '=' + columnInfo);

    for (var o in grid.store.baseParams) {
        baseParams[o] = grid.store.baseParams[o];
    }
}

function EmailPdf(tabPanelId) {
    var send = function() {
        if (!ValidateForm(emailPdfForm)) {
            return;
        }
        var email = trimBoth(emailPdfForm.getForm().findField('email').getValue());
        var filename = emailPdfForm.getForm().findField('fileName').getValue();
        var comment = emailPdfForm.getForm().findField('comment').getValue();
        SaveToPdf(tabPanelId, email, filename, comment);
        emailPdfWindow.hide();
    }
     
     var emailPdfForm = new Ext.form.FormPanel({
        url: '',
        id: 'emailPdfForm',
        region: 'center',
        width: 350,
        border: false,
        monitorValid: true,
        monitorPoll: 250,
        margins: '3 0 3 3',
        cmargins: '3 3 3 3',
        labelWidth: 70,
        bodyStyle: 'background: #cad9ec; padding-top: 10px; padding-left: 5px;',
        defaults: { width: 240 },
        defaultType: 'textfield',
        items: [{
            fieldLabel: 'Email',
            name: 'email',
            allowBlank: false,
            vtype: 'email'
        }, {
            fieldLabel: 'Comment',
            name: 'comment'
        }, {
            fieldLabel: 'File Name',
            name: 'fileName',
            allowBlank: false,
            value: 'report.pdf'
        }],
        buttons: [{
            text: 'Send',
            handler: send
        }, {
            text: 'Cancel',
            handler: function() {
                emailPdfWindow.hide();
            }
        }]
    });

    var emailPdfWindow = new Ext.Window({
        title: 'Email Report',
        closable: true,
        width: 350,
        height: 160,
        plain: true,
        layout: 'border',
        modal: true,
        resizable: false,
        items: [emailPdfForm],
        listeners: {
            show: function() {
                new Ext.KeyMap(Ext.getCmp('emailPdfForm').body, [{
                    key: Ext.EventObject.ENTER,
                    fn: function() {
                        send();
                    },
                    scope: this
                }]);
            }
        }
    });

    emailPdfWindow.show();
}

function SaveToPdf(tabPanelId, email, txt, comment) {
    var domainsTree = Ext.getCmp('domainsTree');
    var treeNodeId = -1;
    var isMonitoringTab = false;

    if (domainsTree) {
        treeNodeId = domainsTree.getSelectionModel().getSelectedNode().id;
        isMonitoringTab = true;
    }

    var tabPanel = Ext.getCmp(tabPanelId);

    var reportInfo = [];

    var baseParams = {};

    for (var t = 0; t < tabPanel.items.items.length; t++) {
        var tab = tabPanel.items.items[t];

        if (tabPanel.getTabEl(tab).style.display == 'none' ||
            tabPanel.getTabEl(tab).className.trim() != 'x-tab-strip-active') {
            continue;
        }

        var grid = findGridComponent(tab.items.items);

        AddGridToPdf(reportInfo, grid, tab.title, baseParams);
    }

    var baseParamList = [];
    
    for (var o in grid.store.baseParams) {
        baseParamList.push(o + '=' + baseParams[o]);
    }

    if (txt == null) {
        txt = 'report.pdf';
    }

    var urlParams = (email ? 'emailPdf' : 'getPdf') + '=true' +
        '&treeNodeId=' + treeNodeId +
        '&filename=' + escape(txt) +
        (email ? '&emailToSend=' + email : '') +
        '&reportInfo=' + reportInfo.join('|') +
        '&' + baseParamList.join('&') +
        '&gmtOffset=' + escape(new Date().getGMTOffset(true)) +
        '&comment=' + comment + '&isMonitoringTab=' + 
        isMonitoringTab;

    if (!email) {
        window.location.href = 'PdfHandler.ashx?' + urlParams;
        setTimeout(function() {
            Ext.Msg.hide();
        }, 3000);
    } else {
        Ext.Msg.wait('Sending...', 'Please wait...');
        Ext.Ajax.request({
            url: 'PdfHandler.ashx?' + urlParams,
            success: function(result) {
                if (Ext.decode(result.responseText).success)
                    Ext.Msg.alert('Information', 'Report was successfully sent.');
                else
                    Ext.Msg.alert('Error', 'Cannot send the report.');
            },
            failure: function() { Ext.Msg.alert('Error', 'Cannot send the report.'); }
        });
    }
}

Ext.onReady(function() {
    var taskRunner = new Ext.util.TaskRunner();

    seRenderer = function(value, p, record, rowIndex, colIndex) {
        return '<div class="keyword-image ' + value + '"><' + '/' + 'div>';
    }

    function adVariationsRenderer(value, p, record, rowIndex, colIndex) {
        if (value == 0)
            return value;
        if (record.data.text.indexOf("<img") != -1) {
            return value;
        }
        else {
            return '<a href="javascript:viewAds(' + record.data.id + ', \'' + record.data.text + '\')" class="link">' + value + '</a>';
        }
    }

    function competitorsRenderer(value, p, record, rowIndex, colIndex) {
        if (value == 0)
            return value;
        if (record.data.text.indexOf("<img") != -1) {
            return value;
        }
        else {
            return '<a href="javascript:viewCompetitors(' + record.data.id + ', \'' + record.data.text + '\')" class="link">' + value + '</a>';
        }
    }

    adRenderer = function(value, p, record, rowIndex, colIndex) {

        if (value == '')
            return '';

        var splitIndex = 0;
        var prevSplitIndex = 0;

        while (splitIndex <= 36 && splitIndex >= 0) {
            prevSplitIndex = splitIndex;
            splitIndex = value.description.indexOf(' ', splitIndex + 1);
        }

        var description1 = value.description;
        var description2 = '';

        if (prevSplitIndex > 1 && prevSplitIndex < value.description.length) {
            description1 = value.description.substr(0, prevSplitIndex);
            description2 = value.description.substr(prevSplitIndex + 1);
        }

        return '<span class="ad" style="width: 250px;"><span style="text-decoration: underline;color: #0000CE; line-height: 18px;">' +
                '<a style="color:blue;text-decoration:underline;" href="' + value.destinationUrl + '" target="_blank">' + value.headline + '</a></span><br>' +
                '<span style="white-space:normal; margin-top: 5px;">' + description1 + '<br>' + description2 + '<br></span>' +
                '<span style="color:green">' + value.displayUrl + '</span><br></span>';
    }

    function resultsRenderer(v) {
        if (v < 0)
            return 'N/A';

        v = (Math.round((v - 0) * 100)) / 100;
        v = (v == Math.floor(v)) ? v + "" : ((v * 10 == Math.floor(v * 10)) ? v + "" : v);
        v = String(v);
        var ps = v.split('.');
        var whole = ps[0];
        var sub = ps[1] ? '.' + ps[1] : ''; //'.00';
        var r = /(\d+)(\d{3})/;
        while (r.test(whole)) {
            whole = whole.replace(r, '$1' + ',' + '$2');
        }
        v = whole + sub;
        if (v.charAt(0) == '-') {
            return '-' + v.substr(1);
        }

        return v;
    }

    function percentRenderer(value, p, record, rowIndex, colIndex) {
        if (value <= 0)
            return 'N/A';

        value = (Math.round((value - 0) * 100));

        return '<a href="javascript:viewOverlappedKeywords(' + record.data.id + ', \'' + record.data.name + '\')" class="link">' + value + '%' + '</a>';
    }

    function bidRenderer(value, p, record, rowIndex, colIndex) {
        if (value <= 0)
            return 'N/A';

        var position = record.data.positionForCpc <= 3 ? '1-3' : '4-6';

        return Ext.util.Format.usMoney(value) + ' (pos. ' + position + ')';
    }

    organicPosRenderer = function(v) {
        return v;
    }

    function adCompetitionRenderer(v) {
        if (v < 0)
            return 'N/A';

        var maxWidth = 40;
        var width = Math.floor((v / 10) * 40);

        return '<div style="border: solid 1px #777777; height: 10px; width:' + maxWidth + 'px;">' +
                    '<div style="background-color: #aAd5c4; height: 10px; width:' + width + 'px">&nbsp;<' + '/div><' + '/div>';
    }

    posRenderer = function(v) {
        return v;
    }

    function competitorRender(v) {
        return '<a class="link" style="font-size: 11px;" target="_blank" href="http://' + v + '">' + v + '</a>';
    }

    function addToListCompetitorRender(value, p, record, rowIndex, colIndex) {

        if (record.json.isMySite) {
            return 'Your website';
        }

        var text = value ? 'Remove from Monitoring List' : 'Add To Monitoring List';
        var functionName = value ? 'deleteFromMonitoring' : 'addToMonitoring';
        var tooltip = value ? 'Stop tracking this domain.' : 'Add up to 5 domains to track under the &quot;Monitor COMPETITORS&quot; tab.';

        var href = '';
        var css = 'link';
        var domType = 'a';

        if (getCookie("userId")) {
            href = 'javascript:' + functionName + '(\'' + record.data.name + '\', ' + record.data.id + ')';
        } else {
            css = 'empty-link';
            tooltip = 'Sign up for a Free 30 Day Trial or Subscribe to the service to<br>' +
                      'be able to add this domain to the Monitoring List';
            domType = 'span';
        }

        return '<div id="searchId' + record.data.name + '"><' + domType + ' class="' + css + '" ext:qtip="' + tooltip + '" style=\"font-size: 11px;\" href="' + href + '">' + text + '</' + domType + '></div>';
    }

    function serachCompetitorRender(value, p, record, rowIndex, colIndex) {
        var tooltip = 'Run a research report on this PPC competitor.';

        var href = 'javascript:competitorSearch(\'' + record.data.name + '\')';
        var css = 'link';
        var domType = 'a';

        if (typeof (isDemo) != 'undefined' && isDemo) {
            css = 'empty-link';
            tooltip = 'Sign up for a Free 30 Day Trial or Subscribe to the service to be ' +
                      'able to run a Keyword Discovery report on this PPC competitor';
            domType = 'span';
        }

        return '<' + domType + ' class="' + css + '" style=\"font-size: 11px;\" ext:qtip="' + tooltip + '" href="' + href + '">Search PPC Competitor</' + domType + '>';
    }

    //***********************************************
    // Progress Bar
    //***********************************************

    var reportProgress = new Ext.ProgressBar({
        text: 'Initializing...',
        width: 800
    });

    if (Ext.getDom('report-progress'))
        reportProgress.render('report-progress');

    var reportStop = new Ext.Button({
        text: 'Stop',
        iconCls: 'delete',
        handler: function() {

            Ext.Msg.wait('Stopping...', 'Please wait...');

            Ext.Ajax.request({
                url: 'memberDataHandler.ashx',
                params: { type: 'stopRequest', 'requestId': requestId },
                success: function(result) {
                    if (Ext.decode(result.responseText).success) {
                        Ext.Msg.alert('Information', 'Report was stopped.');
                    }
                    else
                        Ext.Msg.alert('Error', 'Cannot stop the report.');
                },
                failure: function() { Ext.Msg.alert('Error', 'Cannot stop the report.'); }
            });
        }
    });

    if (Ext.getDom('report-stop'))
        reportStop.render('report-stop');


    //***********************************************
    // Summary Table
    //***********************************************

    var summaryStore = new Ext.data.JsonStore({
        id: 'summary-store',
        url: 'reportDataHandler.ashx?testType=summary',
        baseParams: { type: 'summary', 'requestId': requestId },
        root: 'data',
        totalProperty: 'totalCount',
        idProperty: 'id',

        fields: [
                   { name: 'searchEngine' },
                   { name: 'organicKeywordsCount' },
                   { name: 'organicKeywordsPosition' },
                   { name: 'paidKeywordsCount' },
                   { name: 'paidKeywordsPosition' },
                   { name: 'competitorsCount' },
                   { name: 'adVariationsCount' }
                ]
    });

    var NoDomainData = '<div style="margin-left:15px;"><br><p>There were no PPC results found for the searched domain.</p>' +
                    '<br />' +
                    '<p>This could be because of only a couple reasons:</p>' +
                    '<p>• From your current geo-location setting, the PPC competitor is not running any paid ads.</p>' +
                    '<p>• They are not running any PPC campaigns during the time you searched, probably due to Google ' +
                    'and/or Yahoo budget constraints.</p>' +
                    '<br />' +
                    '<p>If you think this domain is using PPC campaigns, we suggest doing a manual Google and/or ' +
                    'Yahoo search to validate results.</p><div>';

    var NoOrganicKeywordData = 
                    '<div style="margin-left:15px;"><br><p>There were no search results found for the searched domain.</p>' +
                    '<br />' +
                    '<p>The most typical reasons for this include:</p>' +
                    '<p>• Domain name is incorrect (please check the spelling).</p>' +
                    '<p>• Domain was not indexed by Google/Yahoo because it’s a new web site or the SEO value is too low (keywords in wrong places on the site, ' +
                    'no backlinks or backlinks are in wrong pages, etc.).</p>' +
                    '<br />' +
                    '<p>Email us at <a href="mailto:support@keywordcompetitor.com">support@keywordcompetitor.com</a> if you have any additional questions and we’re happy to assist you.</p><div>';

    var NoKeywordData = '<div style="margin-left:15px;"><br><p>There were no PPC results found for the searched keyword.</p><div>';

    var newDataAvaliableLink = '&nbsp;'; /*'<table width="262px"><tr style="line-height: 10px;"><td style="line-height: 12px;" width="8%" align="right">' +
                                '<a style="color: white; text-decoration: none;" href="javascript:refreshData()"><img alt="Refresh" src="resources/images/default/grid/refresh.gif" />&nbsp;</a></td><td width="92%" align="left">' +
                                '<a style="font-size: 14px; color: white;" href="javascript:refreshData()">More data available</a></td></tr></table>';*/

    var runningRequestId = -1;

    var tabsInitializedRequestId = -1;

    var updateAjaxTransactionId = -1;

    var dataCompletedUtc = '';

    var summaryColumnsWidth = [];

    var firstLoad = true;

    function updateReportProgress(doNotRefreshData) {
        if (updateAjaxTransactionId >= 0) {
            Ext.Ajax.abort(updateAjaxTransactionId);
            updateAjaxTransactionId = -1;
        }

        if (requestId > 0) {
            updateAjaxTransactionId = Ext.Ajax.request({
                url: 'reportDataHandler.ashx?testType=updateReportProgress',
                success: function(response, options) {

                    var data = Ext.decode(response.responseText).extraData;

                    if (!data)
                        return;

                    var domainName = document.getElementById('reportDomainName');
                    domainName.innerHTML = data.domainName;
                    var reportTitle = document.getElementById('reportTitleRight');
                    reportTitle.innerHTML = data.reportTitle;
                    var reportDesc = document.getElementById('reportDescription');
                    reportDesc.innerHTML = 'IMPORTANT:<br>This information was collected today and is current ' +
                    'and accurate (not from aged databases that have been storing it for 30+ days). This keyword ' +
                    'data is the latest and most up-to-date information available.';

                    Ext.getDom('progressBigImage').className = data.completed ? 'x-hide-visibility' : '';

                    //                    var closeLink = '<a href="#" style="float: right" onclick="searchingMask.hide();return false;">Close</a><br>';

                    //                    if (searchingMask && searchingMask.visible &&
                    //                        (closeLink + data.progressTip) != searchingMask.msg) {

                    //                        searchingMask.msg = closeLink + data.progressTip;
                    //                        searchingMask.show();

                    //                        var children = searchingMask.el.dom.children;
                    //                        var msgWindow = document.getElementById(children[children.length - 1].id);
                    //                        msgWindow.style.width = '600px';
                    //                        msgWindow.style.top = '20px';
                    //                        msgWindow.style.left = '135px';

                    //                        searchingMask.visible = true;
                    //                    }
                    if (searchingMask && searchingMask.visible) {
                        searchingMask.show();
                        searchingMask.visible = true;
                    }


                    isKeywordReport = data.keywordReport;
                    reportObjectName = data.objectName;

                    var result = new RegExp('(.*) Report').exec(data.domainName);
                    var domain = '';
                    if (result.length >= 2)
                        domain = result[1];

                    if (!Ext.getUrlParam('saveMode')) {
                        SetTableTooltips(data.keywordReport);
                    }

                    if (isRegister == 'True') {
                        var toolTip = Ext.getCmp('monitorDomainTooltip');
                        if (toolTip)
                            toolTip.destroy();

                        var toolTipKeyword = Ext.getCmp('monitorKeywordTooltip');
                        if (toolTipKeyword)
                            toolTipKeyword.destroy();

                        if (data.alreadyExistsInSaved) {
                            Ext.getCmp('addToSaved').setHandler(function() {
                                Ext.Msg.alert('Error', 'Domain already added.');
                            });
                        } else {
                            Ext.getCmp('addToSaved').setHandler(addToSavedHandler);
                        }

                        if (!data.keywordReport) {

                            new Ext.ToolTip({
                                id: 'monitorDomainTooltip',
                                target: 'addToMonitoring',
                                html: 'Track ' + domain + '\'s page rank & ads (up to 5 PPC competitors).'
                            });

                            if (data.alreadyExistsInMonitor) {
                                Ext.getCmp('addToMonitoring').setHandler(function() {
                                    Ext.Msg.alert('Error', 'Domain already added.');
                                });
                            } else {
                                Ext.getCmp('addToMonitoring').setHandler(addToMonitoringHandler);
                            }

                            var activeTab = Ext.getCmp('report-tabs').activeTab;
                            if (activeTab.id != 'paidTab' && activeTab.id != 'organicTab') {
                                new Ext.ToolTip({
                                    id: 'monitorKeywordTooltip',
                                    target: 'addKeywordsToMonitoring',
                                    html: 'Please first click on either the Paid Keywords or Organic Keywords tab, check off which keywords from those lists you wish to monitor, and then click here.'
                                });
                            } else {
                                new Ext.ToolTip({
                                    id: 'monitorKeywordTooltip',
                                    target: 'addKeywordsToMonitoring',
                                    html: 'Track page rank across monitored sites for keywords checked off below.'
                                });
                            }
                        } else {
                            new Ext.ToolTip({
                                id: 'monitorDomainTooltip',
                                target: 'addToMonitoring',
                                width: 380,
                                html: 'You may add a domain you wish to monitor from a report run on that domain (this is a report on a keyword phrase), or, you may add a domain directly in the "Monitor Competitors" page."'
                            });

                            Ext.getCmp('addToMonitoring').setHandler(function() {
                                Ext.Msg.alert('', 'You may add a domain you wish to monitor via a report run on that domain, or, you may add it directly via the above "Monitor Competitors" tab.');
                            });

                            new Ext.ToolTip({
                                id: 'monitorKeywordTooltip',
                                target: 'addKeywordsToMonitoring',
                                html: 'Track the search engine position of "' + domain + '" across monitored sites.'
                            });
                        }

                    }

                    dataCompletedUtc = data.dataCompletedUtc;

                    reportProgress.updateProgress(data.progress, data.progressText);

                    var activeTab = Ext.getCmp('report-tabs').activeTab;
                    if (Ext.getDom('report-progress-status')) {
                        Ext.getDom('report-progress-status').innerHTML = data.statusText;
                    }

                    var summaryTable = Ext.getCmp('summary-grid');
                    var summaryGridColumnModel = summaryTable.getColumnModel();
                    var paidKeywordColumnModel = Ext.getCmp('paid-keywords-grid').getColumnModel();
                    var columnKeyOverlap = Ext.getCmp('unique-competitors-grid').getColumnModel();

                    /*if (isRegister == 'False') {
                    //paidKeywordColumnModel.setHidden(0, true);
                    //columnKeyOverlap.setHidden(3, true);
                    //columnKeyOverlap.setHidden(4, true);
                    }*/

                    if (data.keywordReport) {
                        var tabPanel = Ext.getCmp('report-tabs');
                        tabPanel.hideTabStripItem('paidTab');
                        tabPanel.hideTabStripItem('organicTab');
                        //Ext.getCmp('summary-grid').className = 'visibility-hidden';
                        if (tabPanel.activeTab.id == 'paidTab' ||
                            tabPanel.activeTab.id == 'organicTab')
                            tabPanel.setActiveTab('competitorTab');
                        columnKeyOverlap.setHidden(2, true);

                        summaryGridColumnModel.setHidden(1, true);
                        summaryGridColumnModel.setHidden(2, true);
                        summaryGridColumnModel.setHidden(3, true);
                        summaryGridColumnModel.setHidden(4, true);

                        if (!summaryColumnsWidth[5])
                            summaryColumnsWidth[5] = summaryGridColumnModel.getColumnWidth(5);

                        if (!summaryColumnsWidth[6])
                            summaryColumnsWidth[6] = summaryGridColumnModel.getColumnWidth(6);

                        summaryGridColumnModel.setColumnWidth(5, 395);
                        summaryGridColumnModel.setColumnWidth(6, 395);
                    } else {
                        summaryTable.className = '';
                        summaryTable.doLayout();
                        var tabPanel = Ext.getCmp('report-tabs');
                        tabPanel.unhideTabStripItem('paidTab');
                        tabPanel.unhideTabStripItem('organicTab');
                        columnKeyOverlap.setHidden(2, false);

                        summaryGridColumnModel.setHidden(1, false);
                        summaryGridColumnModel.setHidden(2, false);
                        summaryGridColumnModel.setHidden(3, false);
                        summaryGridColumnModel.setHidden(4, false);

                        if (summaryColumnsWidth[5])
                            summaryGridColumnModel.setColumnWidth(5, summaryColumnsWidth[5]);

                        if (summaryColumnsWidth[6])
                            summaryGridColumnModel.setColumnWidth(6, summaryColumnsWidth[6]);
                    }

                    var tabNames = ['paidTab', 'organicTab', 'competitorTab', 'adsTab'];
                    var dataNames = ['paidKeywordsCount', 'organicKeywordsCount', 'competitorsCount', 'adVariationsCount'];

                    for (var i = 0; i < tabNames.length; i++) {

                        var tab = Ext.getCmp(tabNames[i]);

                        if (data[dataNames[i]] == 0 && data.completed) {

                            var NoDataMessagePanel = tab.items.items[1];

                            if (tab.items.items.length == 2) {

                                tab.remove(NoDataMessagePanel);
                            }

                            NoDataMessagePanel = new Ext.Panel({ border: false, html: '' });
                            tab.add(NoDataMessagePanel);

                            if (!data.keywordReport && NoDataMessagePanel) {
                                if (tabNames[i] != 'organicTab')
                                    NoDataMessagePanel.html = NoDomainData;
                                else
                                    NoDataMessagePanel.html = NoOrganicKeywordData;
                            } else {
                                NoDataMessagePanel.html = NoKeywordData;
                            }

                            tab.items.items[0].hide();
                            tab.items.items[1].show();
                            tab.doLayout();
                        } else {

                            if (tab.items.items.length == 2)
                                tab.remove(tab.items.items[1]);

                            tab.items.items[0].show();

                            if (tab.rendered) {

                                tab.syncSize();
                                tab.items.items[0].syncSize();
                            }
                        }
                    }

                    var reportRunningStatus = data.completed ? 'Report completed.' : 'Report still running.';
                    var newDataAvailableDom = Ext.getDom('newDataAvailable');
                    newDataAvailableDom.innerHTML = newDataAvaliableLink;
                    newDataAvailableDom.className = 'x-hide-visibility';

                    var reportChanged = false;

                    if (data.completed && isTrialUser && !getCookie('dontShowTrialReportCompleted') &&
                        runningRequestId == requestId) {

                        Ext.Msg.alert('Information', 'There are many more keywords available for this PPC competitor. ' +
                                                    'Please upgrade your account to Basic or Professional subscription. ' +
                                                    'Click <a href="subscribe.aspx">here</a> to learn how.');
                    }

                    if (!data.completed)
                        runningRequestId = requestId;
                    else
                        runningRequestId = -1;

                    if (tabsInitializedRequestId != requestId &&
                           (data.completed || data.paidKeywordsCount > 0 || data.organicKeywordsCount > 0)) {

                        reportChanged = true;
                        tabsInitializedRequestId = requestId;
                    }

                    if (reportChanged) {

                        var autoSelectTab = function() {

                            if (!firstLoad)
                                return;

                            firstLoad = false;

                            if (!data.keywordReport) {
                                var sumPaidKeywordsCount = summaryStore.reader.jsonData.data[0].paidKeywordsCount + summaryStore.reader.jsonData.data[1].paidKeywordsCount;
                                var sumOrganicKeywordsCount = summaryStore.reader.jsonData.data[0].organicKeywordsCount + summaryStore.reader.jsonData.data[1].organicKeywordsCount;

                                if (sumPaidKeywordsCount > 0) {
                                    tabPanel.setActiveTab('paidTab');
                                } else if (sumOrganicKeywordsCount > 0) {
                                    tabPanel.setActiveTab('organicTab');
                                } else {
                                    tabPanel.setActiveTab('summaryTab');
                                }
                            }
                        };

                        if (tabPanel.activeTab.id == 'summaryTab') {
                            if (summaryStore.reader.jsonData && summaryStore.reader.jsonData.data.length != 0) {
                                autoSelectTab();
                            } else {
                                summaryStore.on('load', autoSelectTab, this, { single: true });
                            }
                        } /* else {
                            summaryStore.on('load', autoSelectTab, this, { single: true });
                            summaryStore.load();
                        }*/
                    }

                    if (data.keywordReport && typeof (isDemo) != 'undefined' && isDemo) {
                        tabPanel.setActiveTab('competitorTab');
                    }

                    if ((!data.keywordReport && (data.paidKeywordsCount > 0 || data.organicKeywordsCount > 0)) ||
                        (data.keywordReport && (data.competitorsCount > 0 || data.adVariationsCount > 0)) || data.completed) {

                        if (searchingMask && searchingMask.visible) {
                            summaryStore.reader.jsonData = null;

                            searchingMask.hide();
                            searchingMask.visible = false;

                            if (!doNotRefreshData)
                                refreshData();
                        }
                    } else {

                        if (searchingMask && !searchingMask.visible) {

                            searchingMask.msg = 'Initializing...';
                            searchingMask.show();
                            searchingMask.visible = true;
                        }

                        summaryStore.reader.jsonData = null;
                    }

                    if (summaryStore.reader.jsonData != null && summaryStore.reader.jsonData.data.length != 0) {
                        var sumPaidKeywordsCount = summaryStore.reader.jsonData.data[0].paidKeywordsCount + summaryStore.reader.jsonData.data[1].paidKeywordsCount;
                        var sumOrganicKeywordsCount = summaryStore.reader.jsonData.data[0].organicKeywordsCount + summaryStore.reader.jsonData.data[1].organicKeywordsCount;
                        var sumUniqueCompetitorsCount = summaryStore.reader.jsonData.data[0].competitorsCount + summaryStore.reader.jsonData.data[1].competitorsCount;
                        var sumAdsCount = summaryStore.reader.jsonData.data[0].adVariationsCount + summaryStore.reader.jsonData.data[1].adVariationsCount;

                        if (sumPaidKeywordsCount != data.paidKeywordsCount ||
                                sumOrganicKeywordsCount != data.organicKeywordsCount ||
                                sumUniqueCompetitorsCount != data.competitorsCount ||
                                sumAdsCount != data.adVariationsCount) {

                            if (!reportChanged) {
                                //newDataAvailableDom.className = '';
                                refreshData();
                            }
                        }
                    } else {
                        //refreshData();
                    }

                    if (data.completed) {
                        newDataAvailableDom.className = '';
                        newDataAvailableDom.innerHTML = data.ranOn;
                        taskRunner.stop(updateReportTask);
                        if (taskRunnerMember)
                            taskRunnerMember.stop(updateReportTask);

                        if (Ext.getDom('report-progress-container')) {
                            Ext.getDom('report-progress-container').className = 'visibility-hidden';
                        }

                        if (searchingMask && searchingMask.visible) {
                            searchingMask.hide();
                            searchingMask.visible = false;
                        }

                        if (isRegister == 'False' && Ext.getDom('master_pageContent_researchform')) {
                            Ext.getDom('master_pageContent_researchform').className = 'researchform';
                        }

                        if (!doNotRefreshData)
                            refreshData(true);

                        onReportReady();
                    }
                },
                failure: function() { },
                params: { type: 'progress', 'requestId': requestId, gmtOffset: new Date().getGMTOffset(true), 'dataCompletedUtc': dataCompletedUtc }
            });
        }
        else {
            if (Ext.getDom('no-data-container'))
                Ext.getDom('no-data-container').className = 'x-hide-display';

            if (searchingMask && !searchingMask.visible) {
                searchingMask.msg = 'Initializing...';
                searchingMask.show();
                searchingMask.visible = true;
            }
        }
    }

    updateReport = updateReportProgress;

    updateReportTask = {
        run: function() { updateReport(); },
        interval: 10000 //10 seconds
    };

    if (requestId > 0) {
        taskRunner.start(updateReportTask);
    }

    // create the Grid
    var summaryGrid = new Ext.grid.GridPanel({
        id: 'summary-grid',
        store: summaryStore,
        columns: [
                    { header: "Search", width: 60, height: 40, sortable: true, renderer: seRenderer, dataIndex: 'searchEngine' },
                    { header: "Paid Keywords", width: 100, sortable: false, resizable: false, dataIndex: 'paidKeywordsCount' },
                    { header: "Average Paid Keywords Position", width: 170, sortable: false, resizable: false, renderer: posRenderer, dataIndex: 'paidKeywordsPosition' },
                    { header: "Organic Keywords", width: 120, sortable: false, resizable: false, dataIndex: 'organicKeywordsCount' },
                    { header: "Average Organic Keywords Position", width: 210, sortable: false, resizable: false, renderer: organicPosRenderer, dataIndex: 'organicKeywordsPosition' },
                    { header: "PPC Competitors", width: 90, sortable: false, resizable: false, dataIndex: 'competitorsCount' },
                    { header: "Ads", width: 100, sortable: false, resizable: false, dataIndex: 'adVariationsCount' }
                ],
        stripeRows: true,
        trackMouseOver: false,
        disableSelection: true,
        loadMask: true,
        height: 100,
        width: 1000,
        border: false
    });

    /*if (Ext.getDom('summary-table')) {
    summaryGrid.render('summary-table');

        if (requestId) {
    summaryStore.load();
    }
    }*/

    //***********************************************
    // Paid Keywords Table
    //***********************************************

    var paidKeywordsStore = new Ext.data.JsonStore({
        url: 'reportDataHandler.ashx?testType=paidStore',
        baseParams: { type: 'paid', 'requestId': requestId, gmtOffset: new Date().getGMTOffset(true) },
        root: 'data',
        totalProperty: 'totalCount',
        idProperty: 'id',
        remoteSort: true,

        fields: [
                   { name: 'id', type: 'int' },
                   { name: 'text', type: 'string' },
                   { name: 'advertiserCompetitionScale', type: 'int' },
                   { name: 'avgSearchVolume', type: 'int' },
                   { name: 'lastMonthSearchVolume', type: 'int' },
                   { name: 'searchResults', type: 'int' },
                   { name: 'position', type: 'string' },
                   { name: 'adCount', type: 'int' },
                   { name: 'competitorCount', type: 'int' },
                   { name: 'searchEngine' },
                   { name: 'cpc', type: 'float' },
                   { name: 'positionForCpc', type: 'int' }
                ]
    });

    paidKeywordsStore.setDefaultSort('lastMonthSearchVolume', 'desc');

    var ofKeywordsCount;

    if (isRegister == 'False')
        ofKeywordsCount = '<span style="text-decoration: underline;"><b>{2}</b></span>';
    else
        ofKeywordsCount = '{2}';

    var paidKeywordsPagingBar = new Ext.PagingToolbar({
        pageSize: defaultPageSize,
        store: paidKeywordsStore,
        displayInfo: true,
        displayMsg: 'Displaying keywords {0} - {1} of ' + ofKeywordsCount,
        emptyMsg: 'No keywords to display'
    });

    var paidKeywordsGridSelectionModel = new Ext.grid.CheckboxSelectionModel();

    // create the Grid
    var paidKeywordsGrid = new Ext.grid.GridPanel({
        id: 'paid-keywords-grid',
        store: paidKeywordsStore,
        selModel: paidKeywordsGridSelectionModel,
        columns: [
                    paidKeywordsGridSelectionModel,
                    { header: "Search", width: 40, height: 40, sortable: isOnePageReport, renderer: seRenderer, dataIndex: 'searchEngine' },
                    { header: "Keyword", width: 100, sortable: isOnePageReport, dataIndex: 'text' },
                    { header: "Position", width: 100, sortable: isOnePageReport, dataIndex: 'position' },
                    { header: "PPC Competitors", width: 70, sortable: isOnePageReport, renderer: competitorsRenderer, dataIndex: 'competitorCount' },
                    { header: "Ads", width: 45, sortable: isOnePageReport, renderer: adVariationsRenderer, dataIndex: 'adCount' },
                    { header: "Pages of Content", width: 70, sortable: isOnePageReport, renderer: resultsRenderer, dataIndex: 'searchResults' },
                    { header: "Ad Competition", width: 70, sortable: isOnePageReport, renderer: adCompetitionRenderer, dataIndex: 'advertiserCompetitionScale' },
                    { header: "Average Monthly Search Volume", width: 90, sortable: isOnePageReport, renderer: resultsRenderer, dataIndex: 'avgSearchVolume' },
                    { header: "Prior Month's Search Volume", width: 90, sortable: isOnePageReport, renderer: resultsRenderer, dataIndex: 'lastMonthSearchVolume' },
                    { header: "Estimated Avg. Bid ", width: 85, sortable: isOnePageReport, renderer: bidRenderer, dataIndex: 'cpc' }
                ],
        height: 500,
        border: false,
        bbar: paidKeywordsPagingBar,
        trackMouseOver: false,
        disableSelection: true,
        loadMask: true,
        viewConfig: {
            forceFit: true,
            autoFill: true
        }
    }); //# ad variation   



    //***********************************************
    // Organic Keyords Table
    //***********************************************

    var organicKeywordsStore = new Ext.data.JsonStore({
        url: 'reportDataHandler.ashx?testType=organicStore',
        baseParams: { type: 'organic', 'requestId': requestId, gmtOffset: new Date().getGMTOffset(true) },
        root: 'data',
        totalProperty: 'totalCount',
        idProperty: 'id',
        remoteSort: true,

        fields: [
                   { name: 'text', type: 'string' },
                   { name: 'advertiserCompetitionScale', type: 'int' },
                   { name: 'avgSearchVolume', type: 'int' },
                   { name: 'lastMonthSearchVolume', type: 'int' },
                   { name: 'searchResults', type: 'int' },
                   { name: 'position', type: 'string' },
                   { name: 'searchEngine' }
                ]
    });

    organicKeywordsStore.setDefaultSort('lastMonthSearchVolume', 'desc');

    var organicKeywordsPagingBar = new Ext.PagingToolbar({
        pageSize: defaultPageSize,
        store: organicKeywordsStore,
        displayInfo: true,
        displayMsg: 'Displaying organic keywords {0} - {1} of ' + ofKeywordsCount,
        emptyMsg: 'No organic keywords to display'
    });

    var organicKeywordsGridSelectionModel = new Ext.grid.CheckboxSelectionModel();

    // create the Grid
    var organicKeywordsGrid = new Ext.grid.GridPanel({
        id: 'organic-keywords-grid',
        store: organicKeywordsStore,
        selModel: organicKeywordsGridSelectionModel,
        columns: [
                    organicKeywordsGridSelectionModel,
                    { header: "Search", width: 100, height: 40, sortable: isOnePageReport, renderer: seRenderer, dataIndex: 'searchEngine' },
                    { header: "Keyword", width: 400, sortable: isOnePageReport, dataIndex: 'text' },
                    { header: "Position", width: 210, sortable: isOnePageReport, renderer: organicPosRenderer, dataIndex: 'position' },
                    { header: "Pages of Content", width: 130, sortable: isOnePageReport, renderer: resultsRenderer, dataIndex: 'searchResults' },
                    { header: "Ad Competition", width: 130, sortable: isOnePageReport, renderer: adCompetitionRenderer, dataIndex: 'advertiserCompetitionScale' },
                    { header: "Average Monthly Search Volume", width: 170, sortable: isOnePageReport, renderer: resultsRenderer, dataIndex: 'avgSearchVolume' },
                    { header: "Prior Month's Search Volume", width: 160, sortable: isOnePageReport, renderer: resultsRenderer, dataIndex: 'lastMonthSearchVolume' }
                ],
        height: 500,
        border: false,
        bbar: organicKeywordsPagingBar,
        trackMouseOver: false,
        disableSelection: true,
        loadMask: true,
        viewConfig: {
            forceFit: true,
            autoFill: true
        }
    }); //# ad variation

    //***********************************************
    // Competitors Table
    //***********************************************                

    var uniqueCompetitorsStore = new Ext.data.JsonStore({
        url: 'reportDataHandler.ashx?testType=competitorsStore',
        baseParams: { type: 'uniqueCompetitors', 'requestId': requestId, gmtOffset: new Date().getGMTOffset(true) },
        root: 'data',
        totalProperty: 'totalCount',
        idProperty: 'id',
        remoteSort: true,

        fields: [
                   { name: 'id' },
                   { name: 'name', type: 'string' },
                   { name: 'searchEngine' },
                   { name: 'overlap', type: 'float' },
                   { name: 'inCompetitorList' }
                ]
    });

    uniqueCompetitorsStore.setDefaultSort('overlap', 'desc');

    var uniqueCompetitorsPagingBar = new Ext.PagingToolbar({
        pageSize: defaultPageSize,
        store: uniqueCompetitorsStore,
        displayInfo: true,
        displayMsg: 'Displaying PPC competitors {0} - {1} of ' + ofKeywordsCount,
        emptyMsg: 'No PPC competitors to display'
    });

    // create the Grid
    var uniqueCompetitorsGrid = new Ext.grid.GridPanel({
        id: 'unique-competitors-grid',
        store: uniqueCompetitorsStore,
        columns: [
                    { header: "Search", width: 40, sortable: true, renderer: seRenderer, dataIndex: 'searchEngine' },
                    { header: "PPC Competitor", width: 300, sortable: true, renderer: competitorRender, dataIndex: 'name' },
                    { header: "Keyword Overlap", width: 70, sortable: true, renderer: percentRenderer, dataIndex: 'overlap' },
                    { header: "", width: 150, sortable: false, renderer: addToListCompetitorRender, dataIndex: 'inCompetitorList' },
                    { header: "", width: 100, sortable: false, renderer: serachCompetitorRender, dataIndex: 'inCompetitorList' }
                ],
        height: 500,
        border: false,
        bbar: uniqueCompetitorsPagingBar,
        trackMouseOver: false,
        disableSelection: true,
        loadMask: true,
        viewConfig: {
            forceFit: true,
            autoFill: true
        }
    });

    //***********************************************
    // Ads Table
    //***********************************************                

    var uniqueAdsStore = new Ext.data.JsonStore({
        url: 'reportDataHandler.ashx?testType=adsStore',
        baseParams: { type: 'uniqueAds', 'requestId': requestId, gmtOffset: new Date().getGMTOffset(true) },
        root: 'data',
        totalProperty: 'totalCount',
        idProperty: 'id',
        remoteSort: true,

        fields: [
                   { name: 'ad1' },
                   { name: 'ad2' }
                ]
    });

    AdPagingToolbar = Ext.extend(Ext.PagingToolbar, {
        updateInfo: function() {
            if (this.displayEl) {
                var pageData = this.getPageData();
                var count = this.pageSize;

                if (pageData.activePage == pageData.pages) {
                    count = pageData.total - (pageData.pages - 1) * this.pageSize;
                }

                var msg = count == 0 ?
                    this.emptyMsg :
                    String.format(
                        this.displayMsg,
                        this.cursor + 1, this.cursor + count, this.store.getTotalCount()
                    );
                this.displayEl.update(msg);
            }
        }
    });

    var uniqueAdsPagingBar = new AdPagingToolbar({
        pageSize: 10,
        store: uniqueAdsStore,
        displayInfo: true,
        displayMsg: 'Displaying ads {0} - {1} of ' + ofKeywordsCount,
        emptyMsg: 'No ads to display'
    });

    // create the Grid
    var uniqueAdsGrid = new Ext.grid.GridPanel({
        id: 'ads-grid-panel',
        store: uniqueAdsStore,
        columns: [
                    { header: "", width: 50, sortable: false, renderer: adRenderer, dataIndex: 'ad1' },
                    { header: "", width: 50, sortable: false, renderer: adRenderer, dataIndex: 'ad2' }
                ],
        header: false,
        height: 500,
        border: false,
        bbar: uniqueAdsPagingBar,
        trackMouseOver: false,
        disableSelection: true,
        loadMask: true,
        viewConfig: {
            forceFit: true,
            autoFill: true
        }
    }); //# ad variation

    //***********************************************
    // Tabs Definition
    //***********************************************

    var tabItems = new Array();

    tabItems[tabItems.length] = {
        id: 'summaryTab',
        title: 'Report Summary',
        layout: 'fit',
        autoScroll: true,
        items: [summaryGrid]
    };

    tabItems[tabItems.length] = {
        id: 'paidTab',
        title: 'Paid Keywords',
        layout: 'fit',
        autoScroll: true,
        items: [paidKeywordsGrid]
    };

    tabItems[tabItems.length] = {
        id: 'organicTab',
        title: 'Organic Keywords',
        layout: 'fit',
        autoScroll: true,
        items: [organicKeywordsGrid]
    };

    tabItems[tabItems.length] = {
        id: 'competitorTab',
        title: 'PPC Competitors',
        layout: 'fit',
        autoScroll: true,
        items: [uniqueCompetitorsGrid]
    };

    tabItems[tabItems.length] = {
        id: 'adsTab',
        title: 'Ads',
        layout: 'fit',
        autoScroll: true,
        items: [uniqueAdsGrid]
    };

    reportTabs = tabItems;

    var tabs = new Ext.TabPanel({
        id: 'report-tabs',
        deferredRender: true,
        activeTab: 0,
        //bufferResize: true,
        height: 600,
        layoutOnTabChange: true,
        border: false,
        //autoHeight:true,
        items: tabItems
    });

    var moreDataAvailableHTML = '<div id="newDataAvailable" class="x-hide-visibility" style="font-weight: bold; margin-right: 20px; color: white;">' + newDataAvaliableLink + '</div>';

    var headerPanel = new Ext.Panel({
        id: 'report-panel-header',
        bodyStyle: 'background:  #4C4C4C;',
        height: 125,
        border: false,
        width: 1000,
        html: '<div id="reportDomainName" style="width: 490px; height: 60px; color: white; white-space:nowrap; float: left; font-size: 28px; margin-left: 15px; line-height: 60px;"></div>' +
              '<img id="progressBigImage" src="newDesignImages/ajax-loader.gif" alt="" class="x-hide-visibility" />' +
              '<div style="float: right;">' +
              moreDataAvailableHTML +
              '<div id="reportTitleRight" style="font-weight: bold; margin-right: 20px; color: white;"></div>' +
              '</div>' +
              '<div id="reportDescription" style="font-weight: bold; margin-left: 1%; color: white; font-size: 12px; width: 98%"></div>'
    });

    function addToMonitoringHandler() {
        Ext.Msg.wait('Sending...', 'Please wait...');
        Ext.Ajax.request({
            url: 'reportDataHandler.ashx?testType=addToMonitor',
            success: function(result) {

                result = Ext.decode(result.responseText);

                if (result.success) {
                    Ext.getCmp('addToMonitoring').setHandler(function() {
                        Ext.Msg.alert('Error', 'Domain already added.');
                    });
                    Ext.Msg.alert('Information', 'Site was added to monitoring.');

                    EditKeywordList(function() {

                        onSavedReportAdd();

                        if (result.extraData == "-1") {
                            Ext.Msg.confirm('Information', 'Your website is not specificated. Do you want to input it now?', function(btn) {
                                if (btn == 'yes') {
                                    addHomesiteFromReport();
                                }
                            });
                        }
                    });
                } else {

                    var message = result.message + '<br>' + 'Do you want to edit domain list?';

                    Ext.Msg.show({
                        title: 'Information',
                        msg: message,
                        buttons: Ext.Msg.OKCANCEL,
                        fn: function(btn) {

                            if (btn == 'ok') {
                                EditDomainList();
                            }
                        }
                    });
                }
            },
            failure: function() { Ext.Msg.alert('Error', 'Cannot add to monitoring.'); },
            params: { type: 'addToMonitoring', 'requestId': requestId, gmtOffset: new Date().getGMTOffset(true) }
        });
    }

    function addToSavedHandler() {
        Ext.Msg.wait('Saving...', 'Please wait...');
        Ext.Ajax.request({
            url: 'reportDataHandler.ashx?testType=addToSaved',
            success: function(result) {
                if (Ext.decode(result.responseText).success) {
                    Ext.getCmp('addToSaved').setHandler(function() {
                        Ext.Msg.alert('Error', 'Domain already added.');
                    });
                    Ext.Msg.alert('Information', 'Report was added to saved reports.');
                    onSavedReportAdd();
                }
                else
                    Ext.Msg.alert('Error', 'Cannot add to saved reports.');
            },
            failure: function() { Ext.Msg.alert('Error', 'Cannot add to saved reports.'); },
            params: { type: 'addToSaved', 'requestId': requestId }
        });
    }

    var reportPanel = new Ext.Panel({
        id: 'report-panel',
        bodyStyle: 'padding-top:10px; background:  #4C4C4C;',
        width: 1000,
        items: [headerPanel, tabs],
        tbar: new Ext.Toolbar({
            cls: 'toolbar',
            height: 40,
            items: [
            {
                xtype: 'label',
                text: 'Export to: ',
                cls: 'toolbar-label'
            }, {
                id: 'saveToPdf',
                iconCls: 'pdf',
                cls: 'toolbar-button',
                text: 'PDF',
                scope: this,
                handler: function() {
                    SaveToPdf('report-tabs');
                }
            }, {
                id: 'csvexelExport',
                iconCls: 'csvexel',
                cls: 'toolbar-button',
                text: 'CSV',
                handler: function() {
                    var tabPanel = Ext.getCmp('report-tabs');

                    var sortInfoArray = [];

                    for (var i = 0; i < tabPanel.items.items.length; i++) {
                        var tab = tabPanel.items.items[i];
                        var grid = findGridComponent(tab.items.items);
                        var sortInfo = '';
                        if (grid.store.sortInfo != null) {
                            sortInfo = grid.store.sortInfo.field + ' ' + grid.store.sortInfo.direction;
                        }

                        sortInfoArray[i] = tab.id + 'SortInfo=' + sortInfo;
                    }

                    window.location.href = 'reportDataHandler.ashx?testType=csvExport' +
                        '&tabId=' + tabPanel.activeTab.id +
                    //'&sortInfo=' + sortInfo +
                        '&' + sortInfoArray.join('&') +
                        '&type=export' +
                        '&requestId=' + requestId;
                }
            }, {
                xtype: 'label',
                text: '|',
                style: 'font-height: 19px;',
                cls: 'toolbar-label'
            }, {
                xtype: 'label',
                cls: 'toolbar-label',
                html: 'Email as: '
            }, {
                id: 'emailPdfReport',
                iconCls: 'pdf',
                cls: 'toolbar-button',
                text: 'PDF',
                handler: function() {
                    EmailPdf('report-tabs');
                }
            }, {
                id: 'emailReport',
                iconCls: 'html-icon',
                cls: 'toolbar-button',
                text: 'HTML',
                handler: function() {
                    var tabPanel = Ext.getCmp('report-tabs');

                    var sortInfoArray = [];

                    for (var i = 0; i < tabPanel.items.items.length; i++) {
                        var tab = tabPanel.items.items[i];
                        var grid = findGridComponent(tab.items.items);
                        var sortInfo = '';
                        if (grid.store.sortInfo != null) {
                            sortInfo = grid.store.sortInfo.field + ' ' + grid.store.sortInfo.direction;
                        }

                        sortInfoArray[i] = tab.id + 'SortInfo=' + sortInfo;
                    }

                    showEmailReportWindow(tabPanel.activeTab.id, sortInfoArray.join('&'));
                }
            }, {
                xtype: 'label',
                text: '|',
                style: 'font-height: 19px; padding-right: 15px;',
                cls: 'toolbar-label'
            }, {
                id: 'addToSaved',
                iconCls: 'save-icon',
                cls: 'toolbar-small-button',
                text: 'Save Report',
                scope: this,
                handler: addToSavedHandler
            }, '    ', {
                id: 'addToMonitoring',
                iconCls: 'monitor-icon',
                cls: 'toolbar-small-button',
                text: 'Monitor Domain',
                scope: this,
                handler: addToMonitoringHandler
            }, '    ', {
                id: 'addKeywordsToMonitoring',
                iconCls: 'monitor-icon',
                cls: 'toolbar-small-button',
                text: 'Track Keywords',
                scope: this,
                handler: function() {

                    var keywords = new Array();

                    if (!isKeywordReport) {
                        var activeTab = Ext.getCmp('report-tabs').activeTab;

                        if ((activeTab.id != 'paidTab' && activeTab.id != 'organicTab') ||
                        (activeTab.id == 'paidTab' && paidKeywordsGridSelectionModel.getCount() == 0) ||
                        (activeTab.id == 'organicTab' && organicKeywordsGridSelectionModel.getCount() == 0)) {

                            Ext.Msg.alert('', 'Please first click on either the Paid Keywords or Organic Keywords tab,<br>' +
                                          'check off which keywords from those lists you wish to monitor, and then click here.');
                            return;
                        }
                        var domainName = document.getElementById('reportDomainName').innerHTML;
                        var result = new RegExp('(.*) Report').exec(domainName);

                        var domain = '';

                        if (result.length >= 2)
                            domain = result[1];

                        var selectedRecords = [];

                        switch (activeTab.id) {
                            case 'paidTab':
                                selectedRecords = paidKeywordsGridSelectionModel.getSelections();
                                break;
                            case 'organicTab':
                                selectedRecords = organicKeywordsGridSelectionModel.getSelections();
                                break;
                        }

                        for (var i = 0; i < selectedRecords.length; i++) {
                            keywords.push(selectedRecords[i].data.text);
                        }
                    } else {

                        if (reportObjectName) {
                            keywords.push(reportObjectName);
                        } else {
                            Ext.Msg.alert('Error', 'Error while adding keyword.');
                            return;
                        }
                    }

                    function SaveKeywords() {
                        Ext.Msg.wait('Sending...', 'Please wait...');

                        Ext.Ajax.request({
                            url: 'monitoringSettingsHandler.ashx',
                            timeout: 180000, // 3 min
                            params: {
                                type: 'addKeywordsForDomain',
                                keywordText: keywords.join('\r\n'),
                                gmtOffset: new Date().getGMTOffset(true)
                            },
                            success: function(result) {

                                result = Ext.decode(result.responseText);

                                if (result.success) {
                                    Ext.Msg.alert('Information', 'Keyword(s) were added to monitoring.');
                                    onSavedReportAdd();
                                }
                                else
                                    Ext.Msg.alert('Error', result.message);
                            },
                            failure: function() { Ext.Msg.alert('Error', 'Cannot add keywords to monitoring.'); }
                        });
                    }

                    if (!hasHomesite) {
                        addHomesiteFromReport(SaveKeywords);
                    } else {
                        SaveKeywords();
                    }
                }
            }
            ]
        })
    });

    function onTabChanged(tabPanel, tab) {
        var grid = tab.initialConfig.items[0];
        var store = grid.store;
        /*store.lastOptions == null && */
        if (requestId) {

            if (grid.initialConfig.bbar) {
                store.load({ params: { start: 0, limit: grid.initialConfig.bbar.pageSize} });
            } else {
                store.load();
            }
        }
    }

    tabs.on('tabchange', onTabChanged);

    function onReportTabStoreLoad(store) {
        var bottomToolbar = store.grid.getBottomToolbar();
        if (bottomToolbar) {
            for (var i = 0; i < bottomToolbar.items.items.length; i++) {

                if (bottomToolbar.items.items[i].type == 'button') {
                    FillButtonForGuest(bottomToolbar.items.items[i]);
                } else if (bottomToolbar.items.items[i].el.type == 'text') {
                    bottomToolbar.items.items[i].disable();
                }
            }

            try {
                bottomToolbar.loading.el.dom.offsetParent.innerHTML = '<a style="color: black;" href="subscribe.aspx"> more...</a>';
            }
            catch (a) {
            }
        }
    }

    if (isTrialUser) {

        for (var i = 0; i < reportTabs.length; i++) {

            var grid = findGridComponent(reportTabs[i].items);
            var store = grid.getStore();
            store.grid = grid;

            store.on('load', onReportTabStoreLoad);
        }
    }

    if (Ext.getDom('report-table')) {

        reportPanel.render('report-table');

        if (Ext.getDom('report-tables-inner')) {
            searchingMask = new Ext.LoadMask('report-tables-inner', { msg: 'Initializing...', removeMask: true });
            searchingMask.show();
            searchingMask.visible = true;
        }
    }

    if (Ext.getCmp('report-panel') && Ext.getCmp('report-panel').getEl()) {

        var tabsHtmlContainer = Ext.getCmp('report-panel').getEl().child('.x-tab-strip-wrap').child('.x-clear');

        tabsHtmlContainer.dom.className = 'tab-label';
        tabsHtmlContainer.dom.innerHTML = '';
    }

    if (Ext.getUrlParam('saveMode')) {
        var tabPanel = Ext.getCmp('report-tabs');

        var activeTab = tabPanel.activeTab;

        summaryStore.on('load', function() {
            tabPanel.setActiveTab('paidTab');
        }, summaryStore, { single: true });

        paidKeywordsStore.on('load', function() {
            tabPanel.setActiveTab('organicTab');
        }, paidKeywordsStore, { single: true });

        organicKeywordsStore.on('load', function() {
            tabPanel.setActiveTab('competitorTab');
        }, organicKeywordsStore, { single: true });

        uniqueCompetitorsStore.on('load', function() {
            tabPanel.setActiveTab('adsTab');
        }, uniqueCompetitorsStore, { single: true });

        uniqueAdsStore.on('load', function() {
            tabPanel.setActiveTab(activeTab);
        }, uniqueAdsStore, { single: true });
    }
});

    function refreshData(donotHideNewDataAvailable) {

        if (!requestId)
            return;

        var reportTab = Ext.getCmp('report-tabs').getActiveTab();
        var grid = findGridComponent(reportTab.items.items);
        var reportTabStore = grid.store;
        var lastOptions = reportTabStore.lastOptions;
        
        var tabs = Ext.getCmp('report-tabs').items;

        for (var i = 0; i < tabs.length; i++) {
            tabs.items[i].initialConfig.items[0].store.baseParams.requestId = requestId;
            delete tabs.items[i].initialConfig.items[0].store.lastOptions;
        }

        if (!lastOptions && grid.initialConfig.bbar)
            lastOptions = { params: { start: 0, limit: grid.initialConfig.bbar.pageSize} };
            
        reportTabStore.load(lastOptions);

        if (!donotHideNewDataAvailable) {
        
            var newDataAvailable = Ext.getDom('newDataAvailable');

            if (newDataAvailable)
                newDataAvailable.className = 'x-hide-visibility';
        }
    }

    function viewAds(keywordId, keyword)
    {
        var adsWindow = new Ext.Window({
            autoLoad: { url: 'reportDataHandler.ashx?testType=viewAds', params: { type: 'ads', 'keywordId': keywordId, 'requestId': requestId} },
            title:'Ads for keyword "' + keyword + '"',
            bodyStyle: 'padding:10px 10px 10px 10px; background:transparent;',
            width: 310,
            height: 450,
            resizable: false,
            autoScroll: true,
            modal: true,
            plain: true,
            buttonAlign: 'center',
            buttons: [{
                text: 'Close',
                handler: function() { adsWindow.close(); }
            }]
        });
            
        adsWindow.show();
    }
    
    function viewCompetitors(keywordId, keyword)
    {
        var competitorsWindow = new Ext.Window({
        autoLoad: { url: 'reportDataHandler.ashx?testType=viewCompetitors', params: { type: 'competitors', 'keywordId': keywordId, 'requestId': requestId} },
            title: 'PPC competitors for keyword "' + keyword + '"',
            bodyStyle: 'padding:10px 10px 10px 10px; background:transparent;',
            width: 370,
            height: 450,
            resizable: false,
            autoScroll: true,
            modal: true,
            plain: true,
            buttonAlign: 'center',
            buttons: [{
                text: 'Close',
                handler: function() { competitorsWindow.close(); }
            }]
        });
            
        competitorsWindow.show();
    }
    
    function viewOverlappedKeywords(competitorId, competitor)
    {
        var keywordsWindow = new Ext.Window({
        autoLoad: { url: 'reportDataHandler.ashx?testType=viewOverlappedKeywords', params: { type: 'overlappedKeywords', 'competitorId': competitorId, 'requestId': requestId} },
            title: 'Overlapped keywords for PPC competitor "' + competitor + '"',
            bodyStyle: 'padding:10px 10px 10px 10px; background:transparent;',
            width: 370,
            height: 450,
            resizable: false,
            autoScroll: true,
            modal: true,
            plain: true,
            buttonAlign: 'center',
            buttons: [{
                text: 'Close',
                handler: function() { keywordsWindow.close(); }
            }]
        });
            
        keywordsWindow.show();
    }

    function competitorSearch(domain) {
        if (typeof(checkRequestsLimitExceeded) != 'undefined' && checkRequestsLimitExceeded()) {
            Ext.Msg.alert('Error', 'You have exceeded limits of reports count.<br><a href="subscribe.aspx">Subscribe</a> for monitoring feature and unlimited reports.');
        }
        else if (typeof (checkParallelRequestsLimitExceeded) != 'undefined' && checkParallelRequestsLimitExceeded()) {
            Ext.Msg.alert('Error', 'You have exceeded maximum(' + userLimits.MaxParallelRequests + ') number of concurrent requests.');
        } else if (!Ext.getCmp('googleCheckbox').checked && !Ext.getCmp('yahooCheckbox').checked) {
            Ext.Msg.alert('Error', 'No search engines were selected.');
        }
        else {
            var countryState = state.get('countryState', 'US');
            var regionState = state.get('regionState', '');
            var cityState = state.get('cityState', '');
            searchHref = 'default.aspx?searchText=' + domain + '&searchPostback=true&google=' +
            state.get('googleState', false) + '&yahoo=' + state.get('yahooState', false) +
            '&reportType=' + state.get('reportTypeFullState', false) + '&country=' +
            countryState + '&region=' + regionState + '&city=' + cityState;
            window.location.href = searchHref;
        }
    }

    function addToMonitoring(domain, id, onDone) {
        var link = document.getElementById('searchId' + domain);

        if (link) {
            var previousContent = link.innerHTML;
            link.innerHTML = "<i>Adding please wait...</i>";
        }

        Ext.Ajax.request({
            url: 'reportDataHandler.ashx?testType=addToMonitoringCompetitor',
            timeout: 180000, // 3 min
            params: {
                type: 'addCompetitorToMonitoring',
                'requestId': requestId,
                competitor: domain,
                competitorId: id,
                gmtOffset: new Date().getGMTOffset(true)
            },
            success: function(result) {
                result = Ext.decode(result.responseText);
                if (result.success) {
                    Ext.Msg.alert('Information', 'PPC competitor was successfully added in monitoring list.', onDone);
                    if (link) {
                        var tooltip = 'Stop tracking this domain.';
                        link.innerHTML = "<a class=\"link\" ext:qtip=\"" + tooltip + "\" style=\"font-size: 11px;\" href=\"javascript:deleteFromMonitoring('" + domain + "')\" >Remove from monitoring list</a>";
                    }
                    onCompetitorAdd();

                    var treeDomains = Ext.getCmp('domainsTree');
                    if (treeDomains && treeDomains.getRootNode().firstChild.loaded)
                        treeDomains.reloadNodeEx(treeDomains.getRootNode())
                    if (result.extraData == "-1") {
                        Ext.Msg.confirm('Information', 'Your website is not specificated. Do you want to input it now?', function(btn) {
                            if (btn == 'yes') {
                                addHomesiteFromReport();
                            }
                        });
                    }
                }
                else {
                    if (link) {
                        link.innerHTML = previousContent;
                    }

                    var message = result.message + '<br>' + 'Do you want to edit domain list?';

                    Ext.Msg.show({
                        title: 'Information',
                        msg: message,
                        buttons: Ext.Msg.OKCANCEL,
                        fn: function(btn) {

                            if (btn == 'ok') {
                                EditDomainList(onDone);
                            } else {

                                if (onDone) {
                                    onDone();
                                }
                            }
                        }
                    });
                }
            },
            failure: function() {
                if (link) {
                    link.innerHTML = previousContent;
                }

                Ext.Msg.alert('Error', 'Cannot add the PPC competitor.', onDone);
            }
        });
    }

    function deleteFromMonitoring(domain) {
        var link = document.getElementById('searchId' + domain);
        var previousContent = link.innerHTML;
        link.innerHTML = "<i>Removing please wait...</i>";

        Ext.Ajax.request({
            url: 'reportDataHandler.ashx?testType=deletFromMonitor',
            timeout: 180000, // 3 min
            params: { type: 'deleteCompetitorFromMonitoring', 'requestId': requestId, 'domain': domain },
            success: function(result) {
                if (Ext.decode(result.responseText).success) {
                    Ext.Msg.alert('Information', 'PPC competitor was successfully removed from monitoring list.');
                    var tooltip = 'Add up to 5 domains to track under the &quot;Monitor COMPETITORS&quot; tab.';
                    link.innerHTML = "<a class=\"link\" ext:qtip=\"" + tooltip + "\" style=\"font-size: 11px;\" href=\"javascript:addToMonitoring('" + domain + "')\">Add To Monitoring List</a>";
                    onCompetitorAdd();

                    var treeDomains = Ext.getCmp('domainsTree');
                    if (treeDomains)
                        treeDomains.reloadNodeEx(treeDomains.getRootNode())
                }
                else {
                    link.innerHTML = previousContent;
                    Ext.Msg.alert('Error', 'Cannot remove the PPC competitor.');
                }
            },
            failure: function() {
                link.innerHTML = previousContent;
                Ext.Msg.alert('Error', 'Cannot remove the PPC competitor.');
            }
        });
    }

    function addHomesiteFromReport(OnSuccess)
    {
        Ext.Msg.prompt('Adding Homesite', 'Monitoring requires your website.<br>Your website:', function(btn, text) {
            if (btn == 'ok') {
                if (domainValidator.test(text)) {
                    Ext.Msg.wait('Saving...', 'Please wait...');
                    Ext.Ajax.request({
                        url: 'reportDataHandler.ashx?testType=addHomeSite',
                        params: { type: 'addHomeSite', 'homesite': text, 'requestId': requestId },
                        success: function(result) {
                            var response = Ext.decode(result.responseText);
                            if (response.success) {

                                hasHomesite = true;
                                
                                var treeDomains = Ext.getCmp('domainsTree');
                                if (treeDomains)
                                    treeDomains.reloadNodeEx(treeDomains.getRootNode());

                                Ext.Msg.alert('Information', 'Homesite was successfully saved.', OnSuccess);
                            }
                            else
                                Ext.Msg.alert('Error', 'Cannot save the homesite.');
                        },
                        failure: function() { Ext.Msg.alert('Error', 'Cannot save the homesite.'); }
                    });
                }
                else {
                    Ext.Msg.alert('Error', 'The entered domain name does not appear to be valid.');
                }
            }
        });
    }

    function showCheckKeywordsWindow() {

        var keywordsPanel = new Ext.form.FormPanel({
            url: 'reportDataHandler.ashx?testType=showKeywordsPanel',
            baseParams: { type: 'addCheckKeywordsReport', 'requestId': requestId },
            region: 'center',
            width: 300,
            border: false,
            monitorValid: true,
            monitorPoll: 350,
            margins: '3 0 3 3',
            cmargins: '3 3 3 3',
            labelWidth: 50,
            labelAlign: 'top',
            bodyStyle: 'background:#cad9ec; padding-top: 10px; padding-left: 10px;',
            items: [{
                xtype: 'label',
                html: 'Enter one keyword or phrase per line.',
                style: 'font-size:12px;'
            },{
                xtype: 'textarea',
                fieldLabel: 'You have entered <span id=\"keywordsCount\">0</span> keyword(s)',
                id: 'keywordsTextArea',
                height: 120,
                width: 260,
                style: 'margin-top:5px;',
                name: 'keywords',
                allowBlank: false
            }
         ],
            buttons: [{
                text: 'Check',
                //formBind: true,
                handler: function() {

                    if (!ValidateForm(keywordsPanel)) {
                        return;
                    }
                    
                    keywordsPanel.getForm().submit({
                        success: function(f, a) {
                            keywordsEdit.hide();
                            var response = Ext.decode(a.response.responseText);
                            document.location.href = "progress.aspx?id=" + response.extraData;
                        },
                        failure: function(f, a) {
                            Ext.Msg.alert('Error', 'Error occurred while adding request.');
                        }
                    });
                }
            }
         ]
        });

        var updateKeywordsCount = {
            run: checkKeywords,
            interval: 1000
        };

        var taskRunner = new Ext.util.TaskRunner();

        var keywordsEdit = new Ext.Window({
            title: 'Keywords List',
            closable: true,
            width: 300,
            height: 250,
            plain: true,
            layout: 'border',
            modal: true,
            resizable: false,
            items: [keywordsPanel],
            listeners: {
                hide: function() {
                    taskRunner.stop(updateKeywordsCount);
                }
            }
        });

        keywordsEdit.show();

        taskRunner.start(updateKeywordsCount);

        function checkKeywords() {
            var keywordsElement = keywordsPanel.getForm().findField('keywords');
            var keywords = keywordsElement.getValue().split('\n');
            var keywordsCount = keywords.length;
            keywordsElement.setValue = '';
            for (var i = 0; i < keywordsCount; i++) {
                keywordsElement.setValue += keywords[i].split('\r')[0];
                if (i < keywordsCount - 1)
                    keywordsElement.value += '\n';
            }
            if (keywordsCount > 0 && keywords[keywords.length - 1].length === 0)
                keywordsCount--;
            document.getElementById('keywordsCount').innerHTML = keywordsCount;
        }

    }

    function showEmailReportWindow(tabId, sortInfo) {
        var send = function() {
            if (!ValidateForm(emailPanel)) {
                return;
            }

            var text = emailPanel.getForm().findField('email').getValue();
            var comment = emailPanel.getForm().findField('comment').getValue();
            Ext.Msg.wait('Sending...', 'Please wait...');
            Ext.Ajax.request({
                url: 'reportDataHandler.ashx?testType=emailReport&' + sortInfo,
                success: function(result) {
                    if (Ext.decode(result.responseText).success) {
                        sendEmailWindow.hide();
                        Ext.Msg.alert('Information', 'Report was successfully sent.');
                    }
                    else
                        Ext.Msg.alert('Error', 'Cannot send the report.');
                },
                failure: function() { Ext.Msg.alert('Error', 'Cannot send the report.'); },
                params: {
                    type: 'emailReport',
                    'requestId': requestId,
                    emailToSend: text,
                    'tabId': tabId,
                    'sortInfo': sortInfo,
                    'comment': comment
                }
            });
        }

        var emailPanel = new Ext.form.FormPanel({
            id: 'emailPanel',
            region: 'center',
            width: 300,
            border: false,
            monitorValid: true,
            monitorPoll: 350,
            margins: '3 0 3 3',
            cmargins: '3 3 3 3',
            labelWidth: 60,
            bodyStyle: 'background:#cad9ec; padding-top: 10px; padding-left: 10px;',
            defaults: { width: 200 },
            defaultType: 'textfield',
            items: [{
                fieldLabel: 'Email*',
                name: 'email',
                allowBlank: false,
                vtype: 'email'
            }, {
                fieldLabel: 'Comment',
                name: 'comment',
                allowBlank: true
            }],
            buttons: [{
                text: 'OK',
                //formBind: true,
                handler: send
            }, {
                text: 'Cancel',
                handler: function() {
                    sendEmailWindow.hide();
                }
            }]
        });

        var sendEmailWindow = new Ext.Window({
            title: 'Email Report',
            closable: true,
            width: 300,
            height: 140,
            plain: true,
            layout: 'border',
            modal: true,
            resizable: false,
            items: [emailPanel],
            listeners: {
                show: function() {
                    new Ext.KeyMap(Ext.getCmp('emailPanel').body, [{
                        key: Ext.EventObject.ENTER,
                        fn: function() {
                            send();
                        },
                        scope: this
                    }]);
                }
            }
        });
        
        sendEmailWindow.show();
    }

    function addKeywordsWindow(config) {

        var taskRunner = new Ext.util.TaskRunner();

        var updateKeywordsCountTask = {
            run: checkKeywords,
            interval: 1000
        };

        var keywordsPanel = new Ext.form.FormPanel({
            region: 'center',
            border: false,
            monitorValid: true,
            monitorPoll: 350,
            margins: '3 0 3 3',
            cmargins: '3 3 3 3',
            labelWidth: 50,
            labelAlign: 'top',
            bodyStyle: 'background: #cad9ec; padding-top: 10px; padding-left: 10px;',
            items: [{
                xtype: 'label',
                html: config.line1,
                style: 'font-size:12px;'
            }, {
                xtype: 'textarea',
                fieldLabel: config.line2,
                id: 'keywordsTextArea',
                width: 350,
                height: 270,
                labelSeparator: '',
                style: 'margin-top:5px;',
                name: 'keywords',
                allowBlank: true
            }
            ],
            buttons: [{
                text: 'Save',
                handler: function() {

                    config.handler(keywordsPanel.getForm().findField('keywords').getValue(), function() {
                        keywordsEdit.close();
                    });
                }
            }, {
                text: 'Cancel',
                handler: function() {
                    keywordsPanel.getForm().findField('keywords').setRawValue(null);
                    keywordsEdit.close();
                }
            }
        ]
        });

        var keywordsEdit = new Ext.Window({
            title: config.title,
            closable: true,
            width: 400,
            height: config.height ? config.height : 400,
            plain: true,
            layout: 'border',
            modal: true,
            resizable: false,
            closable: false,
            items: [keywordsPanel],
            listeners: {
                hide: function() {
                    taskRunner.stop(updateKeywordsCountTask);
                },
                show: function() {
                    Ext.Msg.wait('Please wait', 'Loading list...');
                    Ext.Ajax.request({
                        url: 'monitoringSettingsHandler.ashx',
                        params: { type: config.loadType },
                        success: function(result) {
                            var keywordList = Ext.decode(result.responseText);
                            var textArea = keywordsPanel.getForm().findField('keywordsTextArea');
                            textArea.setRawValue(keywordList.extraData);
                            Ext.Msg.hide();
                        },
                        failure: function() { Ext.Msg.alert('Error', 'Error while loading data.'); }
                    });
                }
            }
        });

        function checkKeywords() {
            var keywordsElement = keywordsPanel.getForm().findField('keywords');
            var keywords = keywordsElement.getValue().split('\n');
            var keywordsCount = keywords.length;
            keywordsElement.setValue = '';

            if (keywordsCount > 0 && keywords[keywords.length - 1].length === 0)
                keywordsCount--;

            if (document.getElementById('keywordsCount'))
                document.getElementById('keywordsCount').innerHTML = keywordsCount;
        }

        keywordsEdit.show();

        taskRunner.start(updateKeywordsCountTask);
    }

    function SendCommand(commandParams, OnSuccess, OnError) {
        Ext.Msg.wait('Please wait...', 'Working');
        commandParams.gmtOffset = new Date().getGMTOffset(true);
        Ext.Ajax.request({
            url: 'monitoringSettingsHandler.ashx',
            params: commandParams,
            timeout: 180000, // 3 min
            success: function(result) {
                result = Ext.decode(result.responseText);

                if (result.success) {
                    var domainsTree = Ext.getCmp('domainsTree');

                    if (domainsTree) {
                        domainsTree.reloadNodeEx(domainsTree.getRootNode().firstChild);
                    }
                    Ext.Msg.alert('Information', result.message, function() {
                        if (OnSuccess)
                            OnSuccess(result);
                    });
                } else {
                        Ext.Msg.alert('Information', result.message);
                }
            },
            failure: function() { Ext.Msg.alert('Error', 'Error occurred while sending the request.'); }
        });
    }

    function EditDomainList(onSuccess) {

        if (typeof (onSuccess) != 'function') {
            onSuccess = null;
        }

        var config = {
            line1: 'Enter one domain per line.',
            line2: 'You have entered <span id=\"keywordsCount\">0</span> domain(s) (maximum ' + userLimits.MaxMonitoredDomains + ')',
            title: 'Edit Monitoring PPC Competitors',
            loadType: 'getDomainList',
            handler: function(keywordsText, closeWindow) {

                var keywords = keywordsText.replace(/\r/g, '').split('\n');
                var notValidKeywords = new Array();

                for (var i = 0; i < keywords.length; i++) {
                    var text = keywords[i];
                    if (text == '')
                        continue;

                    if (!domainValidator.test(text)) {
                        notValidKeywords.push(text);
                    }
                }
                if (notValidKeywords.length == 0) {
                    SendCommand({ type: 'addDomainList', 'domainListText': keywordsText, gmtOffset: new Date().getGMTOffset(true) },
                            function(result) { // success

                                var domainsTree = Ext.getCmp('domainsTree');

                                if (domainsTree && !domainsTree.getSelectionModel().getSelectedNode()) {
                                    domainsTree.initialConfig.root.firstChild.select();
                                }

                                if (typeof (refreshActiveView) != 'undefined')
                                    refreshActiveView();

                                //if (!state.get('dontShowGeoWindow', false)) {
                                    GetLcationWindow.show('monitoring');
                                //}

                                closeWindow();

                                if (!result.extraData || result.extraData == '')
                                    addHomesite(onSuccess);
                                else if (onSuccess)
                                    onSuccess();
                            },
                                function() { // error
                                //setTimeout(EditKeywordList, 10);
                            });
                } else {
                    Ext.Msg.alert('Error', '<b>The following domains do not appear to be valid:</b><br>' + notValidKeywords.join('<br>'));
                    return false;
                }

                return true;
            }
        };

        addKeywordsWindow(config);
    }
    
    function EditKeywordList(onSuccess) {

        if (typeof (onSuccess) != 'function') {
            onSuccess = null;
        }

        var config = {
            height: 400,
            line1: 'Please enter one or more keywords (up to ' + userLimits.MaxMonitoredKeywords + ') to monitor.',
            line2: 'Enter one phrase per line.',
            title: 'Keywords to be Tracked',
            loadType: 'getMyDomainKeywords',
            handler: function(keywordsText, closeWindow) {

                var keywords = keywordsText.replace(/\r/g, '').split('\n');
                var notValidKeywords = new Array();

                for (var i = 0; i < keywords.length; i++) {
                    var text = keywords[i];
                    if (text == '')
                        continue;

                    if (!broadKeyword.test(text) && !exectKeyword.test(text) && !phraseKeyword.test(text)) {
                        notValidKeywords.push(text);
                    }
                }
                if (notValidKeywords.length == 0) {
                    SendCommand({ type: 'addKeywordList', 'keywordListText': keywordsText },
                            function() {
                                closeWindow();
                                if (onSuccess)
                                    onSuccess();

                                var domainsTree = Ext.getCmp('domainsTree');
                                
                                if (domainsTree && domainsTree.reloadNodeEx) {
                                    domainsTree.reloadNodeEx(domainsTree.getRootNode(), function() {
                                        if (!domainsTree.getSelectionModel().getSelectedNode()) {
                                            domainsTree.initialConfig.root.firstChild.select();
                                        }
                                    });
                                }
                            },
                            function() {
                                //setTimeout(EditKeywordList, 10);
                            });
                } else {
                    Ext.Msg.alert('Error', '<b>The following keywords do not appear to be valid:</b><br>' + notValidKeywords.join('<br>'));
                    return false;
                }

                return true;
            }
        };

        addKeywordsWindow(config);
    }