// Copyright: Ankitects Pty Ltd and contributors
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html

/* eslint
@typescript-eslint/no-non-null-assertion: "off",
@typescript-eslint/no-explicit-any: "off",
 */

import pb from "../backend/proto";
import {
    interpolateBlues,
    interpolateGreens,
    interpolateReds,
    interpolateOranges,
} from "d3-scale-chromatic";
import "d3-transition";
import { select, mouse } from "d3-selection";
import { scaleLinear, scaleSequential } from "d3-scale";
import { axisBottom, axisLeft } from "d3-axis";
import { showTooltip, hideTooltip } from "./tooltip";
import { GraphBounds, setDataAvailable, GraphRange } from "./graphs";
import { area, curveBasis } from "d3-shape";
import { min, histogram, sum, max, Bin, cumsum } from "d3-array";
import { timeSpan, dayLabel } from "../time";
import { I18n } from "../i18n";

interface Reviews {
    mature: number;
    young: number;
    learn: number;
    relearn: number;
    early: number;
}

export interface GraphData {
    // indexed by day, where day is relative to today
    reviewCount: Map<number, Reviews>;
    reviewTime: Map<number, Reviews>;
}

const ReviewKind = pb.BackendProto.RevlogEntry.ReviewKind;
type BinType = Bin<Map<number, Reviews[]>, number>;

export function gatherData(data: pb.BackendProto.GraphsOut): GraphData {
    const reviewCount = new Map<number, Reviews>();
    const reviewTime = new Map<number, Reviews>();
    const empty = { mature: 0, young: 0, learn: 0, relearn: 0, early: 0 };

    for (const review of data.revlog as pb.BackendProto.RevlogEntry[]) {
        const day = Math.ceil(
            ((review.id as number) / 1000 - data.nextDayAtSecs) / 86400
        );
        const countEntry =
            reviewCount.get(day) ?? reviewCount.set(day, { ...empty }).get(day)!;
        const timeEntry =
            reviewTime.get(day) ?? reviewTime.set(day, { ...empty }).get(day)!;

        switch (review.reviewKind) {
            case ReviewKind.REVIEW:
                if (review.lastInterval < 21) {
                    countEntry.young += 1;
                    timeEntry.young += review.takenMillis;
                } else {
                    countEntry.mature += 1;
                    timeEntry.mature += review.takenMillis;
                }
                break;
            case ReviewKind.LEARNING:
                countEntry.learn += 1;
                timeEntry.learn += review.takenMillis;
                break;
            case ReviewKind.RELEARNING:
                countEntry.relearn += 1;
                timeEntry.relearn += review.takenMillis;
                break;
            case ReviewKind.EARLY_REVIEW:
                countEntry.early += 1;
                timeEntry.early += review.takenMillis;
                break;
        }
    }

    return { reviewCount, reviewTime };
}

function totalsForBin(bin: BinType): number[] {
    const total = [0, 0, 0, 0, 0];
    for (const entry of bin) {
        total[0] += entry[1].mature;
        total[1] += entry[1].young;
        total[2] += entry[1].learn;
        total[3] += entry[1].relearn;
        total[4] += entry[1].early;
    }

    return total;
}

/// eg idx=0 is mature count, idx=1 is mature+young count, etc
function cumulativeBinValue(bin: BinType, idx: number): number {
    return sum(totalsForBin(bin).slice(0, idx + 1));
}

export function renderReviews(
    svgElem: SVGElement,
    bounds: GraphBounds,
    sourceData: GraphData,
    range: GraphRange,
    showTime: boolean,
    i18n: I18n
): void {
    const svg = select(svgElem);
    const trans = svg.transition().duration(600) as any;

    const xMax = 1;
    let xMin = 0;
    // cap max to selected range
    switch (range) {
        case GraphRange.Month:
            xMin = -31;
            break;
        case GraphRange.ThreeMonths:
            xMin = -90;
            break;
        case GraphRange.Year:
            xMin = -365;
            break;
        case GraphRange.AllTime:
            xMin = min(sourceData.reviewCount.keys())!;
            break;
    }
    const desiredBars = Math.min(70, Math.abs(xMin!));

    const x = scaleLinear().domain([xMin!, xMax]).nice(desiredBars);
    x.domain([x.domain()[0], xMax]);

    const sourceMap = showTime ? sourceData.reviewTime : sourceData.reviewCount;
    const bins = histogram()
        .value((m) => {
            return m[0];
        })
        .domain(x.domain() as any)
        .thresholds(x.ticks(desiredBars))(sourceMap.entries() as any);

    // empty graph?
    if (!sum(bins, (bin) => bin.length)) {
        setDataAvailable(svg, false);
        return;
    } else {
        setDataAvailable(svg, true);
    }

    x.range([bounds.marginLeft, bounds.width - bounds.marginRight]);
    svg.select<SVGGElement>(".x-ticks")
        .transition(trans)
        .call(axisBottom(x).ticks(7).tickSizeOuter(0));

    // y scale

    const yMax = max(bins, (b: Bin<any, any>) => cumulativeBinValue(b, 4))!;
    const y = scaleLinear()
        .range([bounds.height - bounds.marginBottom, bounds.marginTop])
        .domain([0, yMax]);
    svg.select<SVGGElement>(".y-ticks")
        .transition(trans)
        .call(
            axisLeft(y)
                .ticks(bounds.height / 50)
                .tickSizeOuter(0)
                .tickFormat(((n: number): string => {
                    if (showTime) {
                        return timeSpan(i18n, n / 1000, true);
                    } else {
                        if (Math.round(n) != n) {
                            return "";
                        } else {
                            return n.toString();
                        }
                    }
                }) as any)
        );

    // x bars

    function barWidth(d: any): number {
        const width = Math.max(0, x(d.x1) - x(d.x0) - 1);
        return width ? width : 0;
    }

    const cappedRange = scaleLinear().range([0.2, 0.5]);
    const shiftedRange = scaleLinear().range([0.4, 0.7]);
    const darkerGreens = scaleSequential((n) =>
        interpolateGreens(shiftedRange(n))
    ).domain(x.domain() as any);
    const lighterGreens = scaleSequential((n) =>
        interpolateGreens(cappedRange(n))
    ).domain(x.domain() as any);
    const blues = scaleSequential((n) => interpolateBlues(cappedRange(n))).domain(
        x.domain() as any
    );
    const reds = scaleSequential((n) => interpolateReds(cappedRange(n))).domain(
        x.domain() as any
    );
    const oranges = scaleSequential((n) => interpolateOranges(cappedRange(n))).domain(
        x.domain() as any
    );

    function valueLabel(n: number): string {
        if (showTime) {
            return timeSpan(i18n, n / 1000);
        } else {
            return i18n.tr(i18n.TR.STATISTICS_REVIEWS, { reviews: n });
        }
    }

    function tooltipText(d: BinType, cumulative: number): string {
        const day = dayLabel(i18n, d.x0!, d.x1!);
        const totals = totalsForBin(d);
        const dayTotal = valueLabel(sum(totals));
        let buf = `<table><tr><td>${day}</td><td align=right>${dayTotal}</td></tr>`;
        const lines = [
            [
                darkerGreens(1),
                i18n.tr(i18n.TR.STATISTICS_COUNTS_MATURE_CARDS),
                valueLabel(totals[0]),
            ],
            [
                lighterGreens(1),
                i18n.tr(i18n.TR.STATISTICS_COUNTS_YOUNG_CARDS),
                valueLabel(totals[1]),
            ],
            [
                blues(1),
                i18n.tr(i18n.TR.STATISTICS_COUNTS_LEARNING_CARDS),
                valueLabel(totals[2]),
            ],
            [
                reds(1),
                i18n.tr(i18n.TR.STATISTICS_COUNTS_RELEARNING_CARDS),
                valueLabel(totals[3]),
            ],
            [
                oranges(1),
                i18n.tr(i18n.TR.STATISTICS_COUNTS_EARLY_CARDS),
                valueLabel(totals[4]),
            ],
            ["grey", i18n.tr(i18n.TR.STATISTICS_RUNNING_TOTAL), valueLabel(cumulative)],
        ];
        for (const [colour, label, detail] of lines) {
            buf += `<tr>
            <td><span style="color: ${colour};">■</span>${label}</td>
            <td align=right>${detail}</td>
            </tr>`;
        }
        return buf;
    }

    const updateBar = (sel: any, idx: number): any => {
        return sel
            .attr("width", barWidth)
            .transition(trans)
            .attr("x", (d: any) => x(d.x0))
            .attr("y", (d: any) => y(cumulativeBinValue(d, idx))!)
            .attr("height", (d: any) => y(0) - y(cumulativeBinValue(d, idx)))
            .attr("fill", (d: any) => {
                switch (idx) {
                    case 0:
                        return darkerGreens(d.x0);
                    case 1:
                        return lighterGreens(d.x0);
                    case 2:
                        return blues(d.x0);
                    case 3:
                        return reds(d.x0);
                    case 4:
                        return oranges(d.x0);
                }
            });
    };

    for (const barNum of [0, 1, 2, 3, 4]) {
        svg.select(`g.bars${barNum}`)
            .selectAll("rect")
            .data(bins)
            .join(
                (enter) =>
                    enter
                        .append("rect")
                        .attr("rx", 1)
                        .attr("x", (d: any) => x(d.x0))
                        .attr("y", y(0))
                        .attr("height", 0)
                        .call((d) => updateBar(d, barNum)),
                (update) => update.call((d) => updateBar(d, barNum)),
                (remove) =>
                    remove.call((remove) =>
                        remove.transition(trans).attr("height", 0).attr("y", y(0))
                    )
            );
    }

    // cumulative area

    const areaCounts = bins.map((d: any) => cumulativeBinValue(d, 4));
    areaCounts.unshift(0);
    const areaData = cumsum(areaCounts);
    const yAreaScale = y.copy().domain([0, areaData.slice(-1)[0]]);

    if (areaData.slice(-1)[0]) {
        svg.select("path.area")
            .datum(areaData as any)
            .attr(
                "d",
                area()
                    .curve(curveBasis)
                    .x((d, idx) => {
                        if (idx === 0) {
                            return x(bins[0].x0!);
                        } else {
                            return x(bins[idx - 1].x1!);
                        }
                    })
                    .y0(bounds.height - bounds.marginBottom)
                    .y1((d: any) => yAreaScale(d)) as any
            );
    }

    // // hover/tooltip
    svg.select("g.hoverzone")
        .selectAll("rect")
        .data(bins)
        .join("rect")
        .attr("x", (d: any) => x(d.x0))
        .attr("y", () => y(yMax!))
        .attr("width", barWidth)
        .attr("height", () => y(0) - y(yMax!))
        .on("mousemove", function (this: any, d: any, idx) {
            const [x, y] = mouse(document.body);
            showTooltip(tooltipText(d, areaData[idx + 1]), x, y);
        })
        .on("mouseout", hideTooltip);
}