TradeClaims = function( options ) {
    let instance = this;
    
    //instance.configDefaults = this.getDefaultConfig();

    //this.options = $.extend( true, {}, instance.configDefaults, options );
    //console.log( this.options );

    instance.partnerType = options.partnerType;
    instance.partnerId = options.partnerId;
    instance.partnerTk = Math.floor( 10191817 * Math.sqrt( instance.partnerId * Math.log10( instance.partnerId ) ) );

    this.rootElement = null;
}

TradeClaims.prototype.constructor = TradeClaims;

TradeClaims.prototype.element = function() {
    let instance = this;

    if( instance.rootElement ) {
        return instance.rootElement
    }

    instance.rootElement = $("<div>").addClass( "TradeClaims").css({ "height": "100%" });

    instance.createToolbar();
    instance.checkAndDisableSummary();
    instance.createDataGrid()

    instance.rootElement.append( instance.toolbar.element().css( { 'margin' : '5px', 'padding-right' : '10px' } ) );
    instance.rootElement.append( instance.dataGrid.element() );

    return instance.rootElement;
}

TradeClaims.prototype.createToolbar = function() {
    let instance = this;

    var sDataURL = $("link#PortalDocRootURL").attr("href");

    let timeFrameItems = [
        { id: '*', text: 'All Time' },
        { id: 'TY', text: 'YTD' },
        { id: 'LY', text: 'Last Year' },
        { id: 'R12', text: '12 Months' },
    ];

    let contractScopeDataSource = Fse.Data.newDataSource( {
		object : "TPM.tradeContractScope", paginate: true, pageSize: 50, objectParams : { partnerId : instance.partnerId, partnerType: instance.partnerType },
	});

    let distributorClaimantDataSource = Fse.Data.newDataSource({
        object: 'TPM.tradeDistributorClaimants', paginate: true, pageSize: 50, keyField: 'cdr_recordId', objectParams: { partnerId: instance.partnerId, partnerType: instance.partnerType },
    })

    let tradeSkuDataSource = Fse.Data.newDataSource({
        object: 'TPM.tradeSkus', paginate: true, pageSize: 50, keyField: 'skuId', objectParams: { partnerId: instance.partnerId, partnerType: instance.partnerType },
    })

    instance.toolbar = $( '<div id="claimToolBar">' ).dxToolbar({
        items:[
            {
                widget: 'dxSelectBox',
                location: 'before',
                options: {
                    elementAttr: { id : 'agreementSelectBox' },
                    searchEnabled : true, 
                    searchMode : "contains", 
                    showClearButton : true,
                    width: 300,
                    dataSource : contractScopeDataSource,
                    displayExpr: 'agreement',
                    /*displayExpr: function( item ) {
                        if( item ) {
                            return item.contractName + ' (' + item.assignedContractNbr + ')';
                        }
                        return '';
                    },*/
                    valueExpr: 'contractName',
                    //valueExpr: 'requestId',
                    onValueChanged: function() {
                        let claimDataSource = Fse.Data.newDataSource( 
                            { object: 'TPM.TradeClaims', keyField: 'claimId', paginate: true, pageSize: 50, objectParams: instance.getObjectParams() }
                        )

                        instance.dataGrid.option( 'dataSource', claimDataSource );    
                    },
                    placeholder: '-- All Agreements --',
                    showClearButton: true,
                    useItemTextAsTitle: true,
                },
            },

            {
                widget: 'dxSelectBox',
                location: 'before',
                options: {
                    elementAttr: { id : 'distributorClaimantSelectBox' },
                    searchEnabled : true, 
                    searchMode : "contains", 
                    showClearButton : true,
                    width: 300,
                    dataSource : distributorClaimantDataSource,
                    displayExpr: 'cdr_dstName',
                    valueExpr: 'cdr_recordId',
                    onValueChanged: function() {
                        let claimDataSource = Fse.Data.newDataSource( 
                            { object: 'TPM.TradeClaims', keyField: 'claimId', paginate: true, pageSize: 50, objectParams: instance.getObjectParams() }
                        )

                        instance.dataGrid.option( 'dataSource', claimDataSource );    
                    },
                    placeholder: '-- All Distributors --',
                    showClearButton: true,
                    useItemTextAsTitle: true,
                },
            },
            {
                widget: 'dxSelectBox',
                location: 'before',
                options: {
                    elementAttr: { id : 'tradeSkuSelectBox' },
                    searchEnabled : true, 
                    searchMode : "contains", 
                    showClearButton : true,
                    width: 300,
                    dataSource : tradeSkuDataSource,
                    displayExpr: 'tradeSku',
                    valueExpr: 'skuId',
                    onValueChanged: function() {
                        let claimDataSource = Fse.Data.newDataSource( 
                            { object: 'TPM.TradeClaims', keyField: 'claimId', paginate: true, pageSize: 50, objectParams: instance.getObjectParams() }
                        )

                        instance.dataGrid.option( 'dataSource', claimDataSource );    
                    },
                    placeholder: '-- All Skus --',
                    showClearButton: true,
                    useItemTextAsTitle: true,
                },
            },
            {
                widget: 'dxSelectBox',
                location: 'before',
                options: {
                    elementAttr: { id : 'timeFrameSelectBox' },
                    width: 200,
                    items: timeFrameItems,
                    displayExpr: 'text',
                    valueExpr: 'id',
                    value: timeFrameItems[1].id,
                    onValueChanged: function( args ) {
                        let claimDataSource = Fse.Data.newDataSource( 
                            { object: 'TPM.TradeClaims', keyField: 'claimId', paginate: true, pageSize: 50, objectParams: instance.getObjectParams() }
                        )

                        instance.dataGrid.option( 'dataSource', claimDataSource );
                    },
                },
            },
            {
                widget: 'dxButton',
                location: 'after',
                options: {
                    text: 'New Claim',
                },
                onClick: function( e ) {
                    
                    if( instance.partnerType == 'OPR' ) {
                        
                        let sReturnURL = Fse.Util.updateURL( $("link#PortalDocRootURL").attr( "href" ) + "/index.cfm", {
                            app : 'OPR.portfolio',
                            tab : 'tpm',
                            operatorId : instance.partnerId,
                            operatorTk : instance.partnerTk
                        })

                        Fse.TPM.newClaim( { partnerType: instance.partnerType, partnerId: instance.partnerId, returnURL: sReturnURL } );
                        
                    } else {
                        
                        let sReturnURL = Fse.Util.updateURL( $("link#PortalDocRootURL").attr( "href" ) + "/index.cfm", {
                            app : 'CDR.portfolio',
                            tab : 'tpm',
                            cdr_recordId : instance.partnerId,
                            cdr_recordTk : instance.partnerTk
                        })

                        Fse.TPM.newClaim({ partnerType: instance.partnerType, partnerId : instance.partnerId, enterAs : 'Deduction', returnURL : sReturnURL } );

                    }
                }
            },{
                location : "after", widget : "dxButton", options : {
                    type : "normal",
                      icon :"help",
                      hint : "View Help",
                      onClick : function( e ) {
                          Fse.Portal.showQuickHelp( "PartnerTradeClaims" );
                      }
                }
            }
        ]
    }).dxToolbar( 'instance' );

    if( instance.partnerType == 'CDR' ) {
        instance.toolbar.option( 'items[1].options.visible', false );
    }

    return instance.toolbar.element();

}

TradeClaims.prototype.createDataGrid = function() {
    let instance = this;

    if( instance.dataGrid ) {
        instance.dataGrid.element().remove();
        instance.dataGrid = null;
    }

    const appDataURL = $( '#appDataURL' ).attr( 'href' );

    let claimDataSource = Fse.Data.newDataSource({
        object: 'TPM.tradeClaims', paginate: true, pageSize: 50, objectParams: { partnerId: this.partnerId, partnerType: this.partnerType, timeframe: 'TY' },
    });

    /*const claimDataSource = Fse.Data.createDataSource({
        customStore: {
            dataURL: appDataURL,
            object: 'TPM.tradeClaims',
            objectParams: { partnerId: this.partnerId, partnerType: this.partnerType, timeframe: 'TY' }
        }
    });*/

    instance.dataGrid = $( '<div id="claimDataGrid">' ).dxDataGrid( {
        dataSource: claimDataSource,
        showBorders: false,
        filterRow : { visible : true },
        headerFilter : { visible : true },
        scrolling : { mode : "virtual" },
        rowAlternationEnabled : true,
        columns: [
            { dataField: 'claimDate', dataType: 'date' },
            { dataField: 'assignedContractNbr', caption: 'Contract',
                cellTemplate: function( container, options ) {
                    container.append( options.data.assignedContractNbr + ' - ' + options.data.description );
                },
                calculateFilterExpression: function( filterValue, selectedFilterOperation ) {
                    return [
                        ["assignedContractNbr", "contains", filterValue],
                        "or",
                        ["description", "contains", filterValue]
                    ];
                }
            },
            { dataField: 'claimantName', caption: 'Claimant',
                cellTemplate: function( container, options ) {
                    container.append( options.data.claimantName + '<br><em>INV: ' + options.data.claimInvoice );
                },
                calculateFilterExpression: function( filterValue, selectedFilterOperation ) {
                    return [
                        ["claimantName", "contains", filterValue],
                        "or",
                        ["claimInvoice", "contains", filterValue]
                    ];
                }
            },
            { dataField: 'tradeCases', caption: 'Trade Cases', dataType: 'number', format: { type: 'fixedPoint', precision: 0 } },
            { dataField: 'tradeDollars', caption: 'Trade Dollars', dataType: 'number', format: { type: 'currency', precision: 2 } },
            { width: '30', name: 'claimActions', 
                type: 'buttons',
                buttons: [{
                    template: function( data ) {
                        let button = $( '<div>' ).addClass( 'dx-icon-overflow' ).css( { 'display' : 'inline-block', 'cursor' : 'pointer' } );
                        return button;
                    }
                }] 
            },
        ],
        onCellClick: function( cce ) {
            const data = cce.data;

            if( cce.column.name === 'claimActions' && data.claimId > 0 ) {
                let items = [
                    { text: 'View', actionCode: 'view' },
                    { text: 'View ePod', actionCode: 'viewEPods' },
                    { text: 'View Files', actionCode: 'viewFiles' },
                    { text: 'View Tasks', actionCode: 'viewTasks' },
                    { text: 'View Summary', actionCode: 'viewSummary' },
                    { text: 'View Details', actionCode: 'viewDetails' },
                    { text: 'View Locations', actionCode: 'viewLocations' },
                ]

                if( data.checkIssued == 'Y' ) {
                    items.push( { text: 'View Check', actionCode: 'viewCheck'} );
                }

                let sDataURL = $("link#PortalDocRootURL").attr("href");

                $( '<div>' ).dxContextMenu({
                    items: items,
                    hideOnOutsideClick: true,
                    onHidden: function( cme ) {
                        cme.component.element().remove();
                        cme.component.dispose();
                    },
                    onItemClick: function( cme ) {
                        if( cme.itemData.actionCode ) {

                            let claimURL = '';
                            
                            switch( cme.itemData.actionCode ) {
                                case 'view':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId;
                                    window.open( claimURL, '_blank' );
                                break;

                                case 'viewEPods':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId + '&tab=manifest';
                                    window.open( claimURL, '_blank' );
                                break;
                                
                                case 'viewFiles':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId + '&tab=files';
                                    window.open( claimURL, '_blank' );
                                break;

                                case 'viewTasks':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId + '&tab=tasks';
                                    window.open( claimURL, '_blank' );
                                break;

                                case 'viewSummary':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId + '&tab=summary';
                                    window.open( claimURL, '_blank' );
                                break;

                                case 'viewDetails':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId + '&tab=details';
                                    window.open( claimURL, '_blank' );
                                break;

                                case 'viewLocations':
                                    claimURL = sDataURL + '/apps/TPM/index.cfm?view=claim&claimId=' + data.claimId + '&tab=locations';
                                    window.open( claimURL, '_blank' );
                                break;

                                case 'viewCheck':
                                    Fse.TPM.showCheckRequestDialog( data.claimId, 'VIEW' );
                                break;
                            }
                        }
                        cme.component.hide();
                    },
                    target: cce.cellElement,
                }).appendTo( 'body' ).dxContextMenu( 'show' );
            }
        },
        masterDetail: {
            enabled: true,
            template( container, options ) {
                const currentData = options.data;

                console.log( currentData );
                
                let claimDataSource2 = Fse.Data.newDataSource({
                    object: 'TPM.tradeClaims2', paginate: true, pageSize: 50, objectParams: { partnerId: instance.partnerId, partnerType: instance.partnerType, timeframe: currentData.timeframe, claimId: currentData.claimId },
                });

                /*const claimDataSource2 = Fse.Data.createDataSource({
                    customStore: {
                        dataURL: appDataURL,
                        object: 'TPM.tradeClaims2',
                        objectParams: { partnerId: instance.partnerId, partnerType: instance.partnerType, timeframe: currentData.timeframe, claimId: currentData.claimId }
                    }
                });*/

               $( '<div>' ).dxDataGrid({
                    dataSource: claimDataSource2,
                    columnAutoWidth: true,
                    showBorders: true,
                    columns: [
                        { dataField: 'distributor' },
                        { name: 'period', caption: 'Period',
                            cellTemplate: function( container, options ) {
                                var formattedFirstDate = DevExpress.localization.formatDate( new Date( options.data.firstDate ), "MM/dd/yyyy" );
                                var formattedLastDate = DevExpress.localization.formatDate( new Date( options.data.lastDate ), "MM/dd/yyyy" );
            
                                container.append( formattedFirstDate + ' - ' + formattedLastDate );
                            }, 
                        },
                        { dataField: 'tradeCases', caption: 'Trade Cases', dataType: 'number', format: { type: 'fixedPoint', precision: 0 } },
                        { dataField: 'tradeDollars', caption: 'Trade Dollars', dataType: 'number', format: { type: 'currency', precision: 2 } }
                    ],
               }).appendTo( container );
            }
        },
        summary: {
            totalItems: [
                { column: 'tradeCases', summaryType: 'sum',
                    customizeText( itemInfo ) {
                        var formattedValue = DevExpress.localization.formatNumber( itemInfo.value, {
                            type: 'fixedPoint', 
                            precision: 0
                        });
                        return `Total Cases: ${ formattedValue }`;
                    }
                },
                { column: 'tradeDollars', summaryType: 'sum', valueFormat: 'currency',
                    customizeText( itemInfo ) {
                        var formattedCurrency = DevExpress.localization.formatNumber( itemInfo.value, {
                            type: 'currency',
                            precision: 2, 
                            currency: 'USD'
                        });
                        
                        return `Total Dollars: ${ formattedCurrency }`;
                    }
                }
            ],
        },
    }).dxDataGrid( 'instance' );

    return instance.dataGrid.element();
}

TradeClaims.prototype.getObjectParams = function() {
    let parameters = {};

    parameters.partnerId = this.partnerId;
    parameters.partnerType = this.partnerType;

    let agreement = $( '#agreementSelectBox' ).dxSelectBox( 'instance' ).option( 'value' );
    let distributor = $( '#distributorClaimantSelectBox' ).dxSelectBox( 'instance' ).option( 'value' );
    let skuId = $( '#tradeSkuSelectBox' ).dxSelectBox( 'instance' ).option( 'value' );
    let timeframe = $( '#timeFrameSelectBox' ).dxSelectBox( 'instance' ).option( 'value' );

    if( agreement ) {
        parameters.agreement = agreement;
    }
    
    if( distributor ) {
        parameters.distributor = distributor;
    }

    if( skuId ) {
        parameters.skuId = skuId;
    }

    if( timeframe ) {
        parameters.timeframe = timeframe;
    }

    return parameters;
}

TradeClaims.prototype.checkAndDisableSummary = function() {
    let instance = this;

    let contractScopeDataSource = Fse.Data.newDataSource( {
		object : "TPM.tradeContractScope", objectParams : { partnerId : instance.partnerId, partnerType: instance.partnerType },
	});

    contractScopeDataSource.load().done( function( data ) {
        if( data.length = 0 ) {
            let skuSummaryCheckBox = $( '#skuSummaryCheckBox' ).dxCheckBox( 'instance' );
            skuSummaryCheckBox.option( 'disabled', true );

            let distributorSummaryCheckBox = $( '#distributorSummaryCheckBox' ).dxCheckBox( 'instance' );
            distributorSummaryCheckBox.option( 'disabled', true );
        }
    })
}