(function(){var Component=function(){}
var titleLookup = {
    "A/Prof":	"Associate Professor",
    "Adj/Prof":	"Adjunct Professor",
    "Asst Prof":	"Assistant Professor",
    "Brigadier":	"Brigadier",
    "Brother":	"Brother",
    "Capt":	"Captain",
    "Cmdr":	"Commander",
    "Dame":	"Dame",
    "Det/Insp":	"Detective Inspector",
    "Dr":	"Dr",
    "Em/Prof":	"Emeritus Professor",
    "Father":	"Father",
    "Grp Capt":	"Group Captain",
    "Hon Prof":	"Hon. Professor",
    "Justice":	"Justice",
    "Lord":	"Lord",
    "M.":	"M.",
    "Miss":	"Miss",
    "Mr":	"Mr",
    "Mr/s":	"Mr/s",
    "Mrs":	"Mrs",
    "Ms":	"Ms",
    "Prof":	"Professor",
    "Prof Dame":	"Professor Dame",
    "Prof Dr":	"Professor Dr",
    "Prof Sir":	"Professor Sir",
    "Reader":	"Reader",
    "Rev":	"Reverend",
    "Rev Dr":	"Reverend Dr",
    "Sir":	"Sir",
    "Sister":	"Sister",
    "The Hon":	"The Hon."
};

 
function sumGroup(group)
{
    function reduceAdd(p, v) {
        return p + v.num;
    }
    
    function reduceRemove(p, v) {
        
        return p - v.num;
    }
    
    function reduceInitial() {
      return 0;
    }
    
    return group.reduce(reduceAdd, reduceRemove, reduceInitial);
}

Component.prototype.AddXAxisLabel = function(chart, label)
{
    
     chart.svg()
        .append("text")
        .attr("class", "x-axis-label")
        .attr("text-anchor", "middle")
        .attr("x", chart.width()/2)
        .attr("y", chart.height()-3.5)
        .text(label);
};

Component.prototype.PrimaryFoRFourDigit = function(p) 
{
    
    var forTotals = {};
    
    _.each(p.FieldsOfResearch.data, function(f) {
        var fourDigitCode = f.code.toString().slice(0, 4);
        
        if (forTotals[fourDigitCode] === undefined) {
            forTotals[fourDigitCode] = {code: fourDigitCode, percentage: parseInt(f.percentage, 10)};
        } else {
            forTotals[fourDigitCode].percentage += parseInt(f.percentage, 10);
        }
       
    });
    
    /*
     var max = _.max(forTotals, function(f) {
         return f.percentage;
     });
    
    return max.code.toString();*/
    
    return Project.ForMax(forTotals).code.toString();
};

Component.prototype.TransformVariables = function(v)
{
    var legacySchemeRounds = [1, 2, 3, 4, 5, 6, 7, 8, 65];
    if (legacySchemeRounds.indexOf(this.variables.rootEntity.schemeRoundId) == -1) {
        v.prioritiesLabel = "Science and Research Priorities";
    } else {
        v.prioritiesLabel = "Strategic Research Priorities";
    }
    
    if (rms.config.labels.GrantingOrgShortName == "ONI")
    {
        v.intelligenceSecurityChallengesLabel = "Intelligence";
    } else if (rms.config.labels.GrantingOrgShortName == "Defence")
    {
        v.intelligenceSecurityChallengesLabel = "Security";
    }
    
    v.hasNit = this.entity.hasNit;
    v.fullyAnnounced = this.entity.fullyAnnounced;
    v.schemeRoundLabel = rms.config.labels.SchemeRoundLabel;
    v.proposalLabel = rms.config.labels.ProposalLabel;
    v.proposalsLabel = rms.config.labels.ProposalsLabel;
    v.grantingOrgShortName = rms.config.labels.GrantingOrgShortName;
    v.grantingOrgName = rms.config.labels.GrantingOrgName;
    v.showSRPs = rms.config.labels.GrantingOrgShortName == "ARC";
    v.showIntelligenceSecurityChallenges = rms.config.labels.GrantingOrgShortName == "ONI" || rms.config.labels.GrantingOrgShortName == "Defence";
    v.projectsLabel = rms.config.labels.ProjectsLabel;
    
    return v;
};

Component.prototype.DC = function(data, orgTypes)
{
    var _this = this;
    var lineChunk = 12;
    var chartSize = 420;
    var topChartHeight = 280;
    var margin = {
        top:  0,
        left: 10, 
        right: 20,
        bottom: 40
    };
    var thereShallBeOnlyOne_Colour = '#6baed6';
    
    var supressPartnerOrgsSchemes = ["Linkage Infrastructure, Equipment and Facilities"];
    
    var fundingChart = dc.rowChart('#funding-chart', "summary");
    var approvedChart = dc.pieChart('#approved-chart', "summary");
    var srpChart = dc.rowChart('#srp-chart', "summary");
    var proposalsLabel = rms.config.labels.ProposalsLabel;
    var intelligenceSecurityChart = dc.rowChart('#intelligence-challenges-chart', "summary");
    
    this.stateChart = dc.rowChart('#states-chart', "filtered");
    this.adminOrgChart = dc.rowChart('#admin-orgs-chart', "filtered");
    this.forChart = dc.rowChart('#for-chart', "filtered");
    
    var ndx = crossfilter(data.projects);
    //var all = ndx.groupAll();
    
    var fundingData = [
            { type: "Requested Funds - All " + proposalsLabel, num: data.totalBudget.requested, order: 1},
            { type: "Requested Funds - Approved " + proposalsLabel, num: data.totalBudget.requestedApproved, order: 2},
            { type: "Approved Funds", num: data.totalBudget.approved, order: 3}
        ];
        
    var successRateData = [
            { funded: true, num: data.successRate.approved},
            { funded: false, num: data.successRate.submitted - data.successRate.approved}
        ];
        
    var srpData = [];
    
    _.each(data.srps, function(v, k) {
         srpData.push({ name: k, num: v});
    });
    
    var intelligenceSecurityData = [];
    
    _.each(data.intelligenceSecurityChallenges, function(v, k) {
        intelligenceSecurityData.push({ name: k, num: v});
    });
    
    var fundingNdx = crossfilter(fundingData);
    var successRateNdx = crossfilter(successRateData);
    var srpNdx = crossfilter(srpData);
    var challengeNdx = crossfilter(intelligenceSecurityData);

    var code = ndx.dimension(function (d) {
        return d.ProjectCode;
    });
    
    var approved = successRateNdx.dimension(function (d) {
        return d.funded ? "Approved" : "Not Approved";
    });
    
    var funded = fundingNdx.dimension(function (d) {
        return d.type;
    });
    
    var srps = srpNdx.dimension(function (p) {
        return p.name;
    });
    
    var challenges = challengeNdx.dimension(function (c) {
        return c.name;
    })
    
    var srpsGroup = sumGroup(srps.group());
    var approvedGroup = sumGroup(approved.group());
    var fundingGroup = sumGroup(funded.group());
    var challengesGroup = sumGroup(challenges.group());

    var states = ndx.dimension(function (d) {
        return d.AdminOrganisationStateName;
    });
    var statesGroup = states.group();
    
    var adminOrgs = ndx.dimension(function (d) {
        return d.AdminOrganisation;
    });
    
    var adminOrgsGroup = adminOrgs.group();

    var fors = ndx.dimension(function (p) {
       return Project.PrimaryFoR(p);
    });
    
    var forsGroup = fors.group();

    var partnerOrgsPresent = _.find(data.projects, function(p) {
        if (p.OrganisationParticipantSummary !== undefined && p.OrganisationParticipantSummary.data !== undefined) {
            return _.find(p.OrganisationParticipantSummary.data, function(o) {
                return o.roleId === 4;
            });
        }
        
        return false;
    });
    
    var keyIndustryOrgsPresent = _.find(data.projects, function(p) {
        if (p.OrganisationParticipantSummary !== undefined && p.OrganisationParticipantSummary.data !== undefined) {
            return _.find(p.OrganisationParticipantSummary.data, function(o) {
                return o.roleId === 7 || o.roleId === 8 ;
            });
        }
        
        return false;
    });
    
    if (supressPartnerOrgsSchemes.indexOf(_this.variables.rootEntity.schemeName) !== -1) {
        partnerOrgsPresent = false;
    }
    
     approvedChart
        .width(chartSize) // (optional) define chart width, :default = 200
        .height(topChartHeight) // (optional) define chart height, :default = 200
        .radius(110)
        .dimension(approved) // set dimension
        .group(approvedGroup) // set group
        .minAngleForLabel(0)
        .label(function (d) {
            var name = d.key === "Approved" ? "Approved (" : "Not Approved (";
            var total = _.reduce(approvedGroup.all(), function(memo, num) { return num.value+memo}, 0);
            return name + ((100*d.value)/total).toFixed(0) + "%)";
        });
        
        
        approvedChart.onClick = function() {};
        
      fundingChart
        .width(chartSize)
        .height((topChartHeight))
        .margins(margin)
        .group(fundingGroup)
        .dimension(approved)
        .elasticX(true)
        .keyAccessor(function (d) {
            return d.key + " (" + "$"+ Budget.AddCommas(d.value) + ")";
        })
        .ordering(function (d) {
            return _.find(fundingData, function(x) { return x.type == d.key;}).order;
        })
        
        .title(function(d) {
            return "$"+ Budget.AddCommas(d.value);
        })
        .ordinalColors([thereShallBeOnlyOne_Colour])
        .xAxis().ticks(4);
        
        
        fundingChart.onClick = function() {};
       
        
    srpChart
        .width(chartSize)
        .height(topChartHeight)
        .margins(margin)
        .group(srpsGroup)
        .dimension(srps)
        .elasticX(true)
        .ordinalColors([thereShallBeOnlyOne_Colour])
        .xAxis().ticks(4);
        srpChart.onClick = function() {};
        
    intelligenceSecurityChart
        .width(chartSize)
        .height(topChartHeight)
        .margins(margin)
        .group(challengesGroup)
        .dimension(challenges)
        .elasticX(true)
        .ordinalColors([thereShallBeOnlyOne_Colour])
        .xAxis().ticks(4);
        intelligenceSecurityChart.onClick = function() {};
        
     
    var stateChartHeight = (chartSize / lineChunk) * statesGroup.size();
        
    this.stateChart
        .width(chartSize)
        .height((stateChartHeight)+margin.top + margin.bottom)
        .margins(margin)
        .group(statesGroup)
        .dimension(states)
        .elasticX(true)
        .ordinalColors([thereShallBeOnlyOne_Colour])
        .xAxis().ticks(4);
    
    var adminOrgChartHeight = (chartSize / lineChunk) * adminOrgsGroup.size();
        
    this.adminOrgChart
        .width(chartSize)
        .height((adminOrgChartHeight)+margin.top + margin.bottom)
        .margins(margin)
        .group(adminOrgsGroup)
        .dimension(adminOrgs)
        .elasticX(true)
        .ordinalColors([thereShallBeOnlyOne_Colour])
        .xAxis().ticks(4);
    
    var forChartChartHeight = (chartSize / lineChunk) * forsGroup.size();
  
  
    this.forChart
      .width(chartSize)
        .height((forChartChartHeight)+margin.top + margin.bottom)
        .margins(margin)
        .group(forsGroup)
        .dimension(fors)
        .elasticX(true)
        .ordinalColors([thereShallBeOnlyOne_Colour])
        .label(function (d) {
            if(_this.for20 && _this.for20[d.key]) {
                return _this.for20[d.key].ClassificationName;
            }
            else {
                return _this.for08[d.key].ClassificationName;
            }
        }) 
        .xAxis().ticks(4);
        
    
    
     var projectTable = dc.dataTable('.dc-data-table', "filtered")
        .dimension(code)
        // data table does not use crossfilter group but rather a closure
        // as a grouping function
        .group(function (x) {
       //      return Project.Approved(x) ? "Approved" : "Submitted";
            return "";
        }).size(data.successRate.approved);
        //.size(1000); // (optional) max number of records to be shown, :default = 25
        // There are several ways to specify the columns; see the data-table documentation.
        // This code demonstrates generating the column header automatically based on the columns.
        
        
        var columns = [
             {
                label: rms.config.labels.ProjectLabel + ' ID',
                format: function (d) {
                    return d.ProjectCode;
                }
            },
             {
                label: 'Investigator(s)',
                format: function (d) {
                    return _.reduce(_.sortBy(d.ChiefInvestigators, function(p) { return p.PersonOrdinal;}), function(sum, val) {
                        if (sum !== "") {
                            sum += "; ";
                        }
                        var title = val.Title;
                        if (titleLookup[title] !== undefined) {
                            title = titleLookup[title];
                        }
                        return sum + (title + " " + val.FirstName + " " + val.FamilyName);
                    }, "");
                }
            },
            {
                label: 'Summary', // desired format of column name 'Change' when used as a label with a function.
                format: function (d) {
                    if (d.Title.endsWith("?")) {
                        return d.Title + " " + d.Summary;
                    }
                    return d.Title + ". " + d.Summary;
                }
            },
            {
                label: 'Announced',
                format: function (d) {
                    if(rms.config.labels.GrantingOrgShortName !== "ARC" || _this.variables.entity.schemeRoundId >= 212 || _this.variables.entity.schemeRoundId == 209 || _this.variables.entity.schemeRoundId == 199) 
                    {
                        return d.AnnouncedDate !== undefined ? moment(d.AnnouncedDate).format("DD/MM/YYYY") : "-";
                    } else
                    {
                        return _this.variables.entity.announcementDate !== undefined ? moment(_this.variables.entity.announcementDate).format("DD/MM/YYYY") : "-";
                    }
                }
            },
            {
                label: rms.config.labels.AdminOrganisationLabel, // desired format of column name 'Change' when used as a label with a function.
                format: function (d) {
                    return d.AdminOrganisation;
                }
            }
           
            
        ];
        
        if (partnerOrgsPresent) {
            var orgLookup = _.indexBy(orgTypes, function(o) { return o.OrganisationIdentifier;});
            columns.push( {
                label: 'Partner Organisation(s)', // desired format of column name 'Change' when used as a label with a function.
                format: function (d) {
                    return _.map(_.filter(d.OrganisationParticipantSummary.data, function(o) {
                        return o.roleId == 4 && orgLookup[o.guid] !== undefined;
                    }), function(o) {
                        return o.name.toUpperCase();
                    }).join("; ");
                }
            });
        }
        
        if (keyIndustryOrgsPresent) {
            var orgLookup = _.indexBy(orgTypes, function(o) { return o.OrganisationIdentifier;});
            columns.push( {
                label: 'Industry Partner(s)', // desired format of column name 'Change' when used as a label with a function.
                format: function (d) {
                    return _.map(_.filter(d.OrganisationParticipantSummary.data, function(o) {
                        return (o.roleId == 7 || o.roleId == 8) && orgLookup[o.guid] !== undefined;
                    }), function(o) {
                        return o.name.toUpperCase();
                    }).join("; ");
                }
            });
        }
        
        
         columns.push( {
                label: 'Primary FOR',
                format: function (d) {
                    return _this.PrimaryFoRFourDigit(d);
                }
            });

        /*for (var i in data.budgetCalendarYearTitles) {
            columns.push({
                label: "$ " + data.budgetCalendarYearTitles[i], 
                format: function(year) {
                    return function (d) {
                        return "$" + Budget.AddCommas(d.AllocatedFundingCalendarYears[year].toFixed(2));
                    };
                }(i)
            });
        }*/
        
         columns.push({
                label: "Funding Awarded", 
                format: function(year) {
                    return function (d) {
                        return "$" + Budget.AddCommas(d.AllocatedFunding.toFixed(2));
                    };
                }()
            });
        
        /*_.each (data.unnamedAwardTitles, function(val, name) {
            columns.push({
                label: name, 
                format: function(key) {
                    return function (d) {
                        return d.UnnamedAwardSummary[key] !== undefined ? d.UnnamedAwardSummary[key] : 0;
                    };
                }(name)
            });
        });*/
        
        projectTable.columns(columns);
        
        
        
        
        projectTable.on("postRender", function() {
          $("#loading").hide();
          $("#charts").removeClass("hidden");
        })

        // (optional) sort using the given field, :default = function(d){return d;}
        /*.sortBy(function (d) {
            return _.reduce(_.sortBy(d.ChiefInvestigators, function(p) { return p.PersonOrdinal;}), function(sum, val) {
                        if (sum !== "") {
                            sum += "; ";
                        }
                        return sum + (val.FamilyName.toLowerCase() + ", " + val.Title.toLowerCase() + " " + val.FirstName.toLowerCase());
                    }, "");
        })*/
        
        .sortBy(function(d) {
            return d.AnnouncedDate;
        })
        // (optional) sort order, :default ascending
        .order(d3.descending)
        // (optional) custom renderlet to post-process chart using D3
        .renderlet(function (table) {
            //table.selectAll('.dc-table-group').classed('info', true);
        });
    
        //#### Rendering
        //simply call renderAll() to render all charts on the page
        dc.renderAll("filtered");
        dc.renderAll("summary");
        
        _this.AddXAxisLabel(fundingChart, "$");
        _this.AddXAxisLabel(srpChart, "Number of Approved " + rms.config.labels.ProjectsLabel);
        _this.AddXAxisLabel(this.stateChart, "Number of Approved " + rms.config.labels.ProjectsLabel);
        _this.AddXAxisLabel(this.adminOrgChart, "Number of Approved " + rms.config.labels.ProjectsLabel);
        _this.AddXAxisLabel(this.forChart, "Number of Approved " + rms.config.labels.ProjectsLabel);
        
        
        
        /*
        // or you can render charts belong to a specific chart group
        dc.renderAll('group');
        // once rendered you can call redrawAll to update charts incrementally when data
        // change without re-rendering everything
        dc.redrawAll();
        // or you can choose to redraw only those charts associated with a specific chart group
        dc.redrawAll('group');
        */
    
    //});
    
    _this.dc = dc;
};

Component.prototype.Ready = function()
{
    console.log(this.entity)
    
    $(".-delta-help-link").on("click", function() {
       $("#" + $(this).data("instructions")).toggleClass("hidden");
    });
    
     $("body").on("click", "svg", function(e) {
             e.preventDefault();
             e.stopPropagation();
         });
    
    var _this = this;
    
    $("#rms-navbar-right").on("change", "#scheme-round-select", function(selected) {
        window.location = $(this).find("option:selected").data("id");
    });
    
    $("#rms-navbar-right").on("click", "#reset-filters", function() {
        _this.dc.filterAll("filtered"); 
        _this.dc.renderAll("filtered");
        _this.AddXAxisLabel(_this.stateChart, "Number of Approved Projects");
        _this.AddXAxisLabel(_this.adminOrgChart, "Number of Approved Projects");
        _this.AddXAxisLabel(_this.forChart, "Number of Approved Projects");
    });
    
    
    _this.variables.data.publicProjects.get().done(function(publicProjects) {
    
        _this.for08 = _.indexBy(publicProjects.for08, function(f) {
            return f.ClassificationCode;
        });
        
        _this.for20 = null;
        if(typeof publicProjects.for20 !== 'undefined' && publicProjects.for20 !== null) {
            _this.for20 = _.indexBy(publicProjects.for20, function(f) {
                return f.ClassificationCode;
            });
        }
        
    
        console.log(publicProjects);
          
         _.each(publicProjects.projects, function(d) {
            //d.AllocatedBudget = convertJson(d.AllocatedBudget);
            d.StrategicResearchPriorities = convertJson(d.StrategicResearchPriorities);
            d.IndustrialTransformationPriorities = convertJson(d.IndustrialTransformationPriorities);
            d.FieldsOfResearch = convertJson(d.FieldsOfResearch);
            d.InternationalCollaborations = convertJson(d.InternationalCollaborations);
            d.OrganisationParticipantSummary = convertJson(d.OrganisationParticipantSummary);
            d.Title = d.Title;
        });
        
        var orgTypes;
    
        _this.variables.data.orgTypes.get().done(function(d) {
            orgTypes = d;
       
            _this.DC(publicProjects, orgTypes);   
            
            $(".numProposalsSpan").text(publicProjects.numProposals)
            $(".numApprovedProposalsSpan").text(publicProjects.projects.length)
        });
        
    });
    
    _this.variables.data.announcedSchemeRounds.get().done(function(d) {
        //var source = $("#scheme-round-list-template").html();
        var html = _this.RenderTemplate("schemeRoundList", {schemeRounds: d, schemeRoundId: _this.variables.entity.schemeRoundId, schemeRoundLabel: rms.config.labels.SchemeRoundLabel});
        $("#rms-navbar-right").html(html);
    });
    

    
};
    FormScripts["1b5a37b2-0a7d-41bf-b99b-962f55a561f3"]=Component;})();