module plotting

using StatsPlots, Plots, DataFrames, Statistics, Dates

export plotEverything, plotBars, plotAllDistributions

function plotEverything(df1, df2, settings, memory)
    println("Data is being plotted.")
    dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")
    memory.focus = ""
    memory.yTicks = ((0-240):60:2000) #change for case
    memory.xRotation = 90.0
    memory.xLabel = "stations"
    memory.yLabel = ""
    memory.color = [:chartreuse :yellow2 :lightskyblue :purple]
    memory.linewidth = 0
    memory.barwidth = 0.7
    memory.tickSize = 13
    memory.guidefontsize = 20
    memory.legendSize = 13
    memory.titleSize = 23
    memory.legendPosition = :outerright
    if settings.approach == "registration points"
        memory.yLabel = "deviation in seconds"
        memory.focus = "Line " * settings.analyzedLine
        memory.size = (2000, 1300)
        memory.direction1 =
            settings.stationDict[df1.station[length(df1.station)]]
        memory.direction2 =
            settings.stationDict[df2.station[length(df2.station)]]
        if settings.timePeriod[1] != "no" &&
           settings.timePeriod[1] != "match day" &&
           settings.timePeriod[1] != "rush hour" &&
           settings.analyzedLine != "11"
            memory.title =
                memory.focus *
                " - Direction " *
                memory.direction1 *
                " - " *
                settings.timePeriod[1] *
                "/ " *
                settings.timePeriod[2] *
                " - " *
                settings.quantile[1] *
                " %-Quantile"
            p1 = plotBarsDays(df1, settings, memory)
            memory.title =
                memory.focus *
                " - Direction " *
                memory.direction2 *
                " - " *
                settings.timePeriod[1] *
                "/ " *
                settings.timePeriod[2] *
                " - " *
                settings.quantile[1] *
                " %-Quantile"
            p2 = plotBarsDays(df2, settings, memory)
        elseif settings.timePeriod[1] == "match day" &&
               settings.analyzedLine != "11"
            memory.size = (900, 750)
            memory.title =
                memory.focus *
                " - Direction " *
                memory.direction1 *
                " - Match Day - " *
                settings.quantile[1] *
                " %-Quantile"
            p1 = plotBarsGameOrRushHour(df1, settings, memory)
            memory.title =
                memory.focus *
                " - Direction " *
                memory.direction2 *
                " - Match Day - " *
                settings.quantile[1] *
                " %-Quantile"
            p2 = plotBarsGameOrRushHour(df2, settings, memory)
        elseif settings.timePeriod[1] == "rush hour" &&
               settings.analyzedLine != "11"
            memory.title =
                memory.focus *
                " - Direction " *
                memory.direction1 *
                " - Rush Hour - " *
                settings.quantile[1] *
                " %-Quantile"
            p1 = plotBarsGameOrRushHour(df1, settings, memory)
            memory.title =
                memory.focus *
                " - Direction " *
                memory.direction2 *
                " - Rush Hour - " *
                settings.quantile[1] *
                " % Quantile"
            p2 = plotBarsGameOrRushHour(df2, settings, memory)
        elseif settings.timePeriod[1] == "no"   #no extra settings
            memory.title = memory.focus * " - Direction " * memory.direction1
            p1 = plotBarsMultQuant(df1, settings, memory)
            memory.title = memory.focus * " - Direction " * memory.direction2
            p2 = plotBarsMultQuant(df2, settings, memory)
            memory.title = memory.focus * " - Distribution"
            #plotDistributionInSec(df1, df2, settings, memory)
            plotDistributionInMin(df1, df2, settings, memory)
            if length(settings.allLines) == length(memory.distributionMin)
                #plotAllDistributions(settings, memory)
                #memory.title = "Distribution S-Bahn Stuttgart - 'new' quantiles"
                memory.title = "Distribution S-Bahn Stuttgart - 'danish' quantiles"
                p3 = plotAllDistributions(settings, memory)
                settings.allLines = ["1", "2", "3", "4", "5", "6", "60"]
                pop!(memory.distributionMin)
                memory.title = ""
                p4 = plotAllDistributions(settings, memory)
                all = plot(p3, p4, layout = (2, 1), legend = :bottomright)
                savefig(
                    all,
                    settings.outputFilePath *
                    "\\Plots\\all_Lines" *
                    "_" *
                    dateString *
                    ".pdf",
                )
            end
        end
        dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")
        all = plot(p1, p2, layout = (2, 1), legend = memory.legendPosition)
        savefig(
            all,
            settings.outputFilePath *
            "\\Plots\\" *
            memory.focus *
            " " *
            settings.approach *
            "_" *
            dateString *
            ".pdf",
        )


    elseif settings.approach == "between registration points"
        myTitle1 = ""
        myTitle2 = ""
        memory.yLabel = "deviation - median (seconds)"
        memory.size = (900, 750)
        memory.focus = "Line " * settings.analyzedLine
        memory.direction1 = settings.stationDict[df1.point2[length(df1.point2)]]
        memory.direction2 = settings.stationDict[df2.point2[length(df2.point2)]]
        memory.title = memory.focus * " - Direction " * memory.direction1
        p1 = plotBarsLineSection(df1, settings, memory)
        memory.title = memory.focus * " - Direction " * memory.direction2
        p2 = plotBarsLineSection(df2, settings, memory)
        all = plot(p1, p2, layout = (2, 1), legend = false, size = (800, 600))
        dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")
        savefig(
            all,
            settings.outputFilePath *
            "\\Plots\\" *
            memory.focus *
            " " *
            settings.approach *
            "_" *
            dateString *
            ".pdf",
        )


    end
end

function plotAllDistributions(settings, memory)
    Plots.pyplot()

    y = Any[]
    x = Any[]

    for quantile in settings.quantile
        push!(y, parse(Int, quantile))
    end
    x = memory.distributionMin[1]

    #average september and october; source: DB
    a = [3, 6]
    b = [84.9, 95.8]

    tickX = (0:1:20)
    
    z = plot(
        a,
        b,
        label = "average deviation sept/ oct 2017",
        xlabel = "Deviation (min)",
        ylabel = "Quantile (%)",
        marker = true,
        legend = :bottomright,
        color = :red,
        xticks = tickX,
        size = (840, 600),
    )
    colors = [
        :gray71,
        :slateblue,
        :goldenrod,
        :darkcyan,
        :magenta4,
        :aqua,
        :deeppink,
        :tan4,
    ]
    z = plot!(
        x,
        y,
        title = memory.title,
        label = "line " * settings.allLines[1],
        marker = true,
        color = colors[1],
    )

    for i = 2:length(memory.distributionMin)
        x = memory.distributionMin[i]
        colorN = colors[i]
        z = plot!(
            x,
            y,
            marker = true,
            color = colorN,
            label = "line " * settings.allLines[i],
        )
    end

    dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")

    savefig(
        z,
        settings.outputFilePath *
        "\\Plots\\all_lines_deviation(min)_" *
        dateString *
        ".pdf",
    )

    return z

end

function plotBarsMultQuant(df, settings, memory)

    pyplot()

    stations = Array{Int,1}()
    depOrArr = Array{String,1}()
    quantile = Array{Float64,1}()
    type = Array{String,1}()

    stationList = Any[]

    for index = 1:length(df.station)
        push!(stationList, df.station[index] * "_" * df.DepOrArr[index])
        for numberQuant = 1:length(settings.quantile)
            push!(stations, index)
            currentColumn = df[!, "quantile"*string(numberQuant)]
            push!(quantile, currentColumn[index])
            push!(type, settings.quantile[numberQuant] * "% quantile")
        end
    end

    df_new =
        DataFrame(station = (stations), quantile = (quantile), type = (type))

    memory.stationList = copy(stationList)

    x = plotBars(df_new, memory, settings)

    x = plot!(
        df.AverageDelay,
        linewidth = 3,
        linecolor = :blue,
        marker = true,
        label = "Average",
    )

    return x
end

function plotBarsDays(df, settings, memory)

    pyplot()

    stations = Array{Int,1}()
    depOrArr = Array{String,1}()
    quantile = Array{Float64,1}()
    type = Array{String,1}()

    stationList = Any[]

    for index = 1:length(df.station)
        push!(stationList, df.station[index] * "_" * df.DepOrArr[index])
        for day in settings.timePeriod
            push!(stations, index)
            currentColumn = df[!, "quantile"*settings.quantile[1]*"_"*day]
            push!(quantile, currentColumn[index])
            push!(type, day)
        end
    end

    df_new =
        DataFrame(station = (stations), quantile = (quantile), type = (type))
    memory.stationList = copy(stationList)
    x = plotBars(df_new, memory, settings)

    x = plot!(
        df[!, "average_"*settings.timePeriod[1]],
        linewidth = 3,
        linecolor = :orange,
        label = "Average Delay " * settings.timePeriod[1],
    )
    x = plot!(
        df[!, "average_"*settings.timePeriod[2]],
        linewidth = 3,
        linecolor = :blue,
        label = "Average Delay " * settings.timePeriod[2],
    )


    return x

end

function plotBarsLineSection(df, settings, memory)
    pyplot()

    x = bar(
        df.median,
        xticks = ([1:1:length(df.points);], df.points),
        yticks = ((0-270):30:210),
        legend = false,
        title = memory.title,
        ylabel = memory.yLabel,
        xlabel = memory.xLabel,
        size = (800, 300),
        bar_width = 1.0,
        xtickfontrotation = memory.xRotation,
    )

    return x

end

function plotDistributionInSec(df1, df2, settings, memory)

    mean1 = (mean(df1.quantile1) + mean(df2.quantile1)) / 2
    mean2 = (mean(df1.quantile2) + mean(df2.quantile2)) / 2
    mean3 = (mean(df1.quantile3) + mean(df2.quantile3)) / 2
    mean4 = (mean(df1.quantile4) + mean(df2.quantile4)) / 2

    pyplot()
    y = Any[]
    for quantile in settings.quantile
        push!(y, parse(Int, quantile))
    end

    x = [mean1, mean2, mean3, mean4]

    #Jahrendurschnitt Quelle: DB
    a = [3 * 60, 6 * 60]
    b = [84.9, 95.8]

    z = plot(
        a,
        b,
        title = memory.title,
        label = "average deviation september/october 2017",
        xlabel = "Deviation (sec)",
        ylabel = "Quantile",
        marker = true,
        legend = :bottomright,
        color = :red,
    )

    z = plot!(
        x,
        y,
        marker = true,
        label = "Deviation Line" * settings.analyzedLine,
    )

    dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")

    savefig(
        z,
        settings.outputFilePath *
        "\\Plots\\Line_" *
        settings.analyzedLine *
        "_Deviation(sec)_" *
        dateString *
        ".pdf",
    )

end

function plotDistributionInMin(df1, df2, settings, memory)

    mean1 = (mean(df1.quantile1) + mean(df2.quantile1)) / 2 / 60
    mean2 = (mean(df1.quantile2) + mean(df2.quantile2)) / 2 / 60
    mean3 = (mean(df1.quantile3) + mean(df2.quantile3)) / 2 / 60
    mean4 = (mean(df1.quantile4) + mean(df2.quantile4)) / 2 / 60

    pyplot()
    y = Any[]
    for quantile in settings.quantile
        push!(y, parse(Int, quantile))
    end
    x = [mean1, mean2, mean3, mean4]
    push!(memory.distributionMin, x)

    #Jahrendurschnitt Quelle: DB
    a = [3, 6]
    b = [84.9, 95.8]

    z = plot(
        a,
        b,
        title = memory.title,
        label = "average deviation september/october 2017",
        xlabel = "Deviation (min)",
        ylabel = "Quantile",
        marker = true,
        legend = :bottomright,
        color = :red,
    )

    z = plot!(
        x,
        y,
        marker = true,
        label = "Deviation " * memory.focus,
        color = :blue,
    )



    dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")

    savefig(
        z,
        settings.outputFilePath *
        "\\Plots\\" *
        memory.title *
        dateString *
        ".pdf",
    )

end

function plotRailwayNetworkDistr(df1, df2, settings)
    mean1 = (mean(df1.quantile1) + mean(df2.quantile1)) / 2 / 60
    mean2 = (mean(df1.quantile2) + mean(df2.quantile2)) / 2 / 60
    mean3 = (mean(df1.quantile3) + mean(df2.quantile3)) / 2 / 60
    mean4 = (mean(df1.quantile4) + mean(df2.quantile4)) / 2 / 60

    pyplot()
    y = Any[]
    for quantile in settings.quantile
        push!(y, parse(Int, quantile))
    end
    x = [mean1, mean2, mean3, mean4]

    z = plot(
        x,
        y,
        title = settings.objectInFocus * " - Distribution",
        label = "Deviation " * settings.objectInFocus,
        xlabel = "Deviation (min)",
        ylabel = "Quantile",
        marker = true,
        legend = :bottomright,
    )

    #Durchschnitt September und Oktober Quelle: DB
    a = [3, 6]
    b = [84.9, 95.8]


    z = plot!(a, b, marker = true, label = "Average Deviation 2017")


    dateString = Dates.format(Dates.now(), "yyyy-mm-dd_HH.MM.SS")

    savefig(
        z,
        settings.outputFilePath *
        "\\Plots\\" *
        settings.objectInFocus *
        "_Deviation(min)_" *
        dateString *
        ".pdf",
    )



end

function plotBarsGameOrRushHour(df, settings, memory)


    pyplot()

    stations = Array{Int,1}()
    depOrArr = Array{String,1}()
    quantile = Array{Float64,1}()
    type = Array{String,1}()

    stationList = Any[]

    for index = 1:length(df.station)
        push!(stationList, df.station[index] * "_" * df.DepOrArr[index])
        for indicator in ["yes", "no"]
            push!(stations, index)
            currentColumn = df[!, "quantile"*settings.quantile[1]*"_"*indicator]
            push!(quantile, currentColumn[index])
            push!(type, indicator)
        end
    end
    newType = Any[]
    if settings.timePeriod[1] == "rush hour"
        label1 = "Rush Hour"
        label2 = "'Normal' Time"
    elseif settings.timePeriod[1] == "match day"
        label1 = "Match Day"
        label2 = "'Normal' Day"
    end
    for x in type
        if x == "yes"
            push!(newType, label1)
        else
            push!(newType, label2)
        end
    end

    df_new =
        DataFrame(station = (stations), quantile = (quantile), type = (newType))

    memory.size = (2000, 1000)
    memory.stationList = copy(stationList)

    x = plotBars(df_new, memory, settings)

    x = plot!(
        df[!, "average_yes"],
        linewidth = 3,
        linecolor = :orange,
        label = "Average Delay " * label1,
    )
    x = plot!(
        df[!, "average_no"],
        linewidth = 3,
        linecolor = :blue,
        label = "Average Delay " * label2,
    )

    return x

end

function plotBars(df, memory, settings)

    if settings.analyzedLine == "11" &&
       memory.title == "Line 11 - Direction Herrenberg"
        memory.yTicks = ((0-240):120:3000)
    end

    x = groupedbar(
        df.quantile,
        xticks = ([1:1:size(memory.stationList, 1);], memory.stationList),
        yticks = memory.yTicks,
        group = df.type,
        ylabel = memory.yLabel,
        xlabel = memory.xLabel,
        title = memory.title,
        size = memory.size,
        bar_width = memory.barwidth,
        linewidth = memory.linewidth,
        tickfontsize = memory.tickSize,
        legendfontsize = memory.legendSize,
        guidefontsize = memory.guidefontsize,
        titlefontsize = memory.titleSize,
        xtickfontrotation = memory.xRotation,
        legend = memory.legendPosition,
    )

    return x

end

end