#r "nuget: Plotly.NET, 4.2.0"
#r "nuget: Plotly.NET.Interactive, 4.2.0"
#r "nuget: FSharp.Data"

open FSharp.Data
open Plotly.NET

[<Literal>]
let exoplanetsFile = "../data/consolidatedExoplanets.csv"

type ExoPlanetType = FSharp.Data.CsvProvider<exoplanetsFile, HasHeaders=true, PreferOptionals=true>
let planets = ExoPlanetType.GetSample()

let getYearOfDiscovery (ref: string) = 
    let found = RegularExpressions.Regex.Matches(ref, " \d{4}")
    match found.Count with
    | 0 -> None
    | 1 -> Some (found.[0].Value.Trim(' ') |> int) 
    | _ -> failwith "More than one year found"
    

type ExoCensusData =
    {
        DiscoveryMethodName : string 
        OrbitTimes: decimal 
        Masses: decimal  
        YearOfDiscovery: int 
    }

let data =
    planets.Rows 
    |> Seq.map (fun row -> (row.Discoverymethod, row.Pl_orbper, row.Pl_masse, getYearOfDiscovery row.Disc_refname))
    |> Seq.choose (fun (method, period, mass, year) -> 
        match period,mass,year with
        | Some p, Some m, Some y -> Some {DiscoveryMethodName = method; OrbitTimes = p; Masses = m; YearOfDiscovery = y}
        | _ -> None)

data.DisplayTable()

let dataByDiscoveryMethod = 
    data 
    |> Seq.groupBy (fun exoData -> exoData.DiscoveryMethodName)

type ExoTrace = 
    {
        DiscoveryMethodName : string 
        OrbitTimes : seq<decimal>
        Masses : seq<decimal>
        }

let exoTraces = 
    dataByDiscoveryMethod
    |> Seq.map (fun (method, data) -> 
            let orbits = data |> Seq.map (fun exoData -> exoData.OrbitTimes)
            let masses = data |> Seq.map (fun exoData -> exoData.Masses)
            {DiscoveryMethodName = method; OrbitTimes = orbits; Masses = masses})

open Plotly.NET.LayoutObjects // this namespace contains all object abstractions for layout styling

let orbPeriodAxis =
    LinearAxis.init (
        Title = Title.init (Text = "ORBIT PERIOD (EARTH DAYS)"),
        AxisType = StyleParam.AxisType.Log,
        ShowLine = true,
        ShowGrid = false,
        Range = StyleParam.Range.MinMax (-2, 8),
        Ticks = StyleParam.TickOptions.Outside
    )

let massLogAxis =
    LinearAxis.init (
        Title = Title.init (Text = "PLANET MASS (EARTH MASSES)"),
        AxisType = StyleParam.AxisType.Log,
        ShowLine = true,
        ShowGrid = false,
        Ticks = StyleParam.TickOptions.Outside
    )

let openCircle = 
    StyleParam.MarkerSymbol.Modified(
            StyleParam.MarkerSymbol.Circle,
            StyleParam.SymbolStyle.Open
        )  

open Plotly.NET.ConfigObjects

let layout =
    Layout.init(
                Width = 1000,
                Height = 500
    )

exoTraces
|> Seq.map (fun exo -> 
                Chart.Point(exo.OrbitTimes,exo.Masses, Name = exo.DiscoveryMethodName)
                |> Chart.withMarkerStyle(Symbol=openCircle))
|> Chart.combine
|> Chart.withXAxis orbPeriodAxis
|> Chart.withYAxis massLogAxis
|> Chart.withLayout layout 

let yearsOfDiscovery = [1989..1..2023]
yearsOfDiscovery

let exoTracesUpToYear year =
    dataByDiscoveryMethod
    |> Seq.map (fun (method, data) -> 
            let dataUpToYear = 
                data 
                |> Seq.filter (fun exoData -> exoData.YearOfDiscovery <= year)

            let orbits = 
                dataUpToYear
                |> Seq.map (fun exoData -> exoData.OrbitTimes)
            let masses = 
                dataUpToYear 
                |> Seq.map (fun exoData -> exoData.Masses)
            {DiscoveryMethodName = method; OrbitTimes = orbits; Masses = masses}
            )
    |> Seq.sortBy (fun exo -> exo.DiscoveryMethodName)

yearsOfDiscovery
    |> Seq.map (fun year -> year,exoTracesUpToYear year |> Seq.length)
    |> Seq.iter (fun (year,count) -> printfn "%d,%d" year count)

let numberOfDiscoveryMethods = 9 

let visibleInit = 
    Array.create (numberOfDiscoveryMethods * (yearsOfDiscovery |> Seq.length)) false    

visibleInit |> Seq.length // 9 (métodos de descubrimiento) x 35 (años desde 1989 a 2023 incluído)= 315

let setVisibleForYear year = 
    let i0 = year - 1989 
    visibleInit
    |> Seq.mapi (fun i visible -> 
                    if i >= (i0 * numberOfDiscoveryMethods) && 
                       i <  ((i0 + 1) * numberOfDiscoveryMethods) then true
                    else false 
                )
    |> Array.ofSeq
                    

let visibility1989 = setVisibleForYear 1989
visibility1989.DisplayTable()

let visibility1990 = setVisibleForYear 1990
visibility1990.DisplayTable()

let sliderSteps =
    yearsOfDiscovery
    |> Seq.indexed
    |> Seq.map (fun (i, year) ->
        // Create a visibility and a title parameter
        // The visibility parameter includes an array where every parameter
        // is mapped onto the trace visibility
        let visible = setVisibleForYear year |> box  // box convierte un tipo en un objeto genérico
        let title = sprintf "Year: %d" year |> box

        SliderStep.init (
            Args = [ "visible", visible; "title", title ],
            Method = StyleParam.Method.Update,
            Label = string (year)
        ))
        

let slider =
    Slider.init (
        CurrentValue = SliderCurrentValue.init (Prefix = "Year: "),
        Padding = Padding.init (T = 50),
        Steps = sliderSteps
    )        

let exoCensusChart =
    Seq.init yearsOfDiscovery.Length (fun i -> i)
    |> Seq.map (fun yearIdx ->        
        // Some plot must be visible here or the chart is empty at the beginning
        let chartVisibility = 
            if yearIdx = 0 then
                StyleParam.Visible.True
            else
                StyleParam.Visible.False

        let go =
            (yearIdx + 1989)
            |> exoTracesUpToYear
            |> Seq.map (fun exo -> 
                            Chart.Point(exo.OrbitTimes,exo.Masses, Name = exo.DiscoveryMethodName)
                            |> Chart.withMarkerStyle(Symbol=openCircle)
                            |> Chart.withTraceInfo (Visible = chartVisibility))
            |> Chart.combine            

        go) 
    |> GenericChart.combine
    |> Chart.withXAxis orbPeriodAxis
    |> Chart.withYAxis massLogAxis
    |> Chart.withLayout layout 

let chart = exoCensusChart |> Chart.withSlider slider

chart

chart |> Chart.saveHtml "exoplanets census"