namespace Plotly.NET

open DynamicObj

open System

open Newtonsoft.Json

open System.Runtime.CompilerServices

open Giraffe.ViewEngine

open System

open System.IO

open System.Collections.Generic

/// Figure is a domain transfer object that can be used to serialize a Chart to JSON. It is used internally and for most use cases should not be used directly.

///

/// Use `GenericChart.toJson` to create a JSON string of a Chart containing the data, layout and config of the GenericChart, or `GenericChart.toFigureJson` for json objects with the data, layout, and an empty frame array.

type Figure =

{

[<JsonProperty("data")>]

Data: Trace list

[<JsonProperty("layout")>]

Layout: Layout

[<JsonProperty("frames")>]

Frames: Frame list

}

static member create data layout =

{

Data = data

Layout = layout

Frames = []

}

/// ChartDTO is a domain transfer object that can be used to serialize a Chart to JSON. It is used internally and for most use cases should not be used directly.

///

/// Use `GenericChart.toJson` to create a JSON string of a Chart containing the data, layout and config of the GenericChart, or `GenericChart.toFigureJson` for json objects with the data, layout, and an empty frame array.

type ChartDTO =

{

[<JsonProperty("data")>]

Data: Trace list

[<JsonProperty("layout")>]

Layout: Layout

[<JsonProperty("config")>]

Config: Config

}

static member create data layout config =

{

Data = data

Layout = layout

Config = config

}

/// The central type that gets created by all Chart constructors is GenericChart, which itself represents either a single chart or a multi chart (as a Discriminate Union type).

///

/// A GenericChart consists of four top level objects: Trace (multiple of those in the case of a MultiChart), Layout, Config, and DisplayOptions.

///

/// - `Trace` is in principle the representation of a dataset on a chart, including for example the data itself, color and shape of the visualization, etc.

///

/// - `Layout` is everything of the chart that is not dataset specific - e.g. the shape and style of axes, the chart title, etc.

///

/// - `Config` is an object that configures high level properties of the chart like making all chart elements editable or the tool bar on top

///

/// - `DisplayOptions` is an object that contains meta information about how the html document that contains the chart.

[<TypeFormatterSourceAttribute(typeof<GenericChartFormatterSource>)>]

type GenericChart =

| Chart of data: Trace * layout: Layout * config: Config * displayOpts: DisplayOptions

| MultiChart of data: Trace list * layout: Layout * config: Config * displayOpts: DisplayOptions

/// Method to support dumping charts in LINQPad.

// See https://www.linqpad.net/CustomizingDump.aspx

member private this.ToDump () : System.Object =

let html = GenericChart.toEmbeddedHTML this

let iFrameType = Type.GetType("LINQPad.Controls.IFrame, LINQPad.Runtime")

if isNull iFrameType then

this

else

let iFrame = System.Activator.CreateInstance(iFrameType, html, true);

iFrame

/// <summary>

/// Creates a Figure DTO from the given GenericChart.

/// </summary>

/// <param name="gChart">The GenericChart to convert</param>

static member toFigure (gChart: GenericChart) =

Figure.create

(GenericChart.getTraces gChart)

(GenericChart.getLayout gChart)

/// <summary>

/// Creates a GenericChart from the given Figure DTO.

/// </summary>

/// <param name="fig">The Figure DTO to convert</param>

static member fromFigure (fig: Figure) =

let traces = fig.Data

let layout = fig.Layout

if traces.Length <> 1 then

MultiChart(traces, layout, Defaults.DefaultConfig, Defaults.DefaultDisplayOptions)

else

Chart(traces.[0], layout, Defaults.DefaultConfig, Defaults.DefaultDisplayOptions)

/// <summary>

/// Creates a ChartDTO from the given GenericChart.

/// </summary>

/// <param name="gChart">The GenericChart to convert</param>

static member toChartDTO (gChart: GenericChart) =

ChartDTO.create

(GenericChart.getTraces gChart)

(GenericChart.getLayout gChart)

(GenericChart.getConfig gChart)

/// <summary>

/// Creates a GenericChart from the given ChartDTO.

/// </summary>

/// <param name="dto">The ChartDTO to convert</param>

static member fromChartDTO (dto: ChartDTO) =

let traces = dto.Data

let layout = dto.Layout

let config = dto.Config

if traces.Length <> 1 then

MultiChart(traces, layout, config, Defaults.DefaultDisplayOptions)

else

Chart(traces.[0], layout, config, Defaults.DefaultDisplayOptions)

/// <summary>

/// Returns all traces of a given GenericChart.

/// </summary>

/// <param name="gChart">the input GenericChart to get all traces from</param>

static member getTraces gChart =

match gChart with

| Chart(trace, _, _, _) -> [ trace ]

| MultiChart(traces, _, _, _) -> traces

/// <summary>

/// Returns the layout of a given GenericChart.

/// </summary>

/// <param name="gChart">the input GenericChart to get the layout from</param>

static member getLayout gChart =

match gChart with

| Chart(_, layout, _, _) -> layout

| MultiChart(_, layout, _, _) -> layout

/// <summary>

/// Returns a new GenericChart with the given layout.

/// </summary>

/// <param name="layout">the layout to set</param>

/// <param name="gChart">the input GenericChart to set the layout on</param>

static member setLayout layout gChart =

match gChart with

| Chart(t, _, c, d) -> Chart(t, layout, c, d)

| MultiChart(t, _, c, d) -> MultiChart(t, layout, c, d)

/// <summary>

/// Returns a new GenericChart with the given layout combined with the given GenericChart's existing layout.

/// </summary>

/// <param name="layout">the layout to add</param>

/// <param name="gChart">the input GenericChart to set the layout on</param>

static member addLayout layout gChart =

match gChart with

| Chart(trace, l', c, d) -> Chart(trace, (Layout.combine l' layout), c, d)

| MultiChart(traces, l', c, d) -> MultiChart(traces, (Layout.combine l' layout), c, d)

/// <summary>

/// Returns a tuple containing the width and height of a GenericChart's layout if the property is set, otherwise None.

/// </summary>

/// <param name="gChart">the input GenericChart to get the layout size from</param>

static member tryGetLayoutSize gChart =

let layout = GenericChart.getLayout gChart

layout.TryGetTypedPropertyValue<int> "width", layout.TryGetTypedPropertyValue<int> "height"

/// <summary>

/// Returns the config of a given GenericChart.

/// </summary>

/// <param name="gChart">the input GenericChart to get the config from</param>

static member getConfig gChart =

match gChart with

| Chart(_, _, c, _) -> c

| MultiChart(_, _, c, _) -> c

/// <summary>

/// Returns a new GenericChart with the given config.

/// </summary>

/// <param name="config">the config to set</param>

/// <param name="gChart">the input GenericChart to set the config on</param>

static member setConfig config gChart =

match gChart with

| Chart(t, l, _, d) -> Chart(t, l, config, d)

| MultiChart(t, l, _, d) -> MultiChart(t, l, config, d)

/// <summary>

/// Returns a new GenericChart with the given config combined with the given GenericChart's existing config.

/// </summary>

/// <param name="config">the config to add</param>

/// <param name="gChart">the input GenericChart to set the config on</param>

static member addConfig config gChart =

match gChart with

| Chart(trace, l, c', d) -> Chart(trace, l, (Config.combine c' config), d)

| MultiChart(traces, l, c', d) -> MultiChart(traces, l, (Config.combine c' config), d)

/// <summary>

/// Returns the DisplayOptions of a given GenericChart.

/// </summary>

/// <param name="gChart">the input GenericChart to get the DisplayOptions from</param>

static member getDisplayOptions gChart =

match gChart with

| Chart(_, _, _, d) -> d

| MultiChart(_, _, _, d) -> d

/// <summary>

/// Returns a new GenericChart with the given DisplayOptions.

/// </summary>

/// <param name="displayOpts">the DisplayOptions to set</param>

/// <param name="gChart">the input GenericChart to set the DisplayOptions on</param>

static member setDisplayOptions displayOpts gChart =

match gChart with

| Chart(t, l, c, _) -> Chart(t, l, c, displayOpts)

| MultiChart(t, l, c, _) -> MultiChart(t, l, c, displayOpts)

/// <summary>

/// Returns a new GenericChart with the given DisplayOptions combined with the given GenericChart's existing DisplayOptions.

/// </summary>

/// <param name="displayOpts">the DisplayOptions to add</param>

/// <param name="gChart">the input GenericChart to set the DisplayOptions on</param>

static member addDisplayOptions displayOpts gChart =

match gChart with

| Chart(t, l, c, d') -> Chart(t, l, c, (DisplayOptions.combine d' displayOpts))

| MultiChart(t, l, c, d') -> MultiChart(t, l, c, (DisplayOptions.combine d' displayOpts))

/// <summary>

/// Combines a collection of GenericCharts, meaning that the traces, layout, config and display options of all elements are combined and returned as a single new GenericChart.

///

/// Combination occurs step-wise in a `Seq.reduce`, where duplicate properties are overwritten on the accumulator by the current element in the collection.

///

/// Traces are simply appended to a single list accumulator.

///

/// Layout, Config, and DisplayOptions can contain properties that themselves are collections. These are combined by appending the values of the second to the first:

///

/// - Layout: annotations, shapes, selections, images, sliders, hiddenlabels, updatemenus

///

/// - Config: modeBarButtonsToAdd

///

/// - DisplayOptions: AdditionalHeadTags, Description

/// </summary>

/// <param name="gCharts">the input GenericCharts to combine</param>

static member combine (gCharts: seq<GenericChart>) =

// temporary hard fix for some props, see https://github.com/CSBiology/DynamicObj/issues/11

gCharts

|> Seq.reduce (fun acc elem ->

match acc, elem with

| MultiChart(traces, l1, c1, d1), Chart(trace, l2, c2, d2) ->

MultiChart(

List.append traces [ trace ],

Layout.combine l1 l2,

Config.combine c1 c2,

DisplayOptions.combine d1 d2

)

| MultiChart(traces1, l1, c1, d1), MultiChart(traces2, l2, c2, d2) ->

MultiChart(

List.append traces1 traces2,

Layout.combine l1 l2,

Config.combine c1 c2,

DisplayOptions.combine d1 d2

)

| Chart(trace1, l1, c1, d1), Chart(trace2, l2, c2, d2) ->

MultiChart(

[ trace1; trace2 ],

Layout.combine l1 l2,

Config.combine c1 c2,

DisplayOptions.combine d1 d2

)

| Chart(trace, l1, c1, d1), MultiChart(traces, l2, c2, d2) ->

MultiChart(

List.append [ trace ] traces,

Layout.combine l1 l2,

Config.combine c1 c2,

DisplayOptions.combine d1 d2

))

/// <summary>

/// Returns the HTML node representation of a given GenericChart.

///

/// The resulting HTML node contains a a div tag containing the chart, and a script tag containing the javascript to create it.

///

/// Note that no references to the necessary scripts are included, so these must be added separately.

/// </summary>

/// <param name="gChart">The input GenericCharts to return as HTML nodes</param>

static member toChartHTMLNodes gChart =

let tracesJson =

let traces = GenericChart.getTraces gChart

JsonConvert.SerializeObject(traces, Globals.JSON_CONFIG)

let layoutJson =

let layout = GenericChart.getLayout gChart

JsonConvert.SerializeObject(layout, Globals.JSON_CONFIG)

let configJson =

let config = GenericChart.getConfig gChart

JsonConvert.SerializeObject(config, Globals.JSON_CONFIG)

let displayOpts = GenericChart.getDisplayOptions gChart

let chartDescription =

displayOpts |> DisplayOptions.getChartDescription

let plotlyReference =

displayOpts |> DisplayOptions.getPlotlyReference

div

[]

[

yield!

HTML.CreateChartHTML(

data = tracesJson,

layout = layoutJson,

config = configJson,

plotlyReference = plotlyReference

)

yield! chartDescription

]

/// <summary>

/// Returns the HTML string representation of a given GenericChart.

///

/// The resulting HTML string contains a a div tag containing the chart, and a script tag containing the javascript to create it.

///

/// Note that no references to the necessary scripts are included, so these must be added separately.

/// </summary>

/// <param name="gChart">The input GenericChart to return as HTML string</param>

static member toChartHTML gChart =

gChart |> GenericChart.toChartHTMLNodes |> RenderView.AsString.htmlNode

/// <summary>

/// Returns the HTML string representation of a given GenericChart embedded into a full HTML document.

///

/// The resulting HTML string contains a head tag with references according to the input GenericChart's DisplayOptions,

/// and a body tag containing the chart div, a script tag containing the javascript to create the chart, and a div tag containing the chart description.

/// </summary>

/// <param name="gChart">The input GenericChart to return as HTML string</param>

static member toEmbeddedHTML gChart =

let tracesJson =

let traces = GenericChart.getTraces gChart

JsonConvert.SerializeObject(traces, Globals.JSON_CONFIG)

let layoutJson =

let layout = GenericChart.getLayout gChart

JsonConvert.SerializeObject(layout, Globals.JSON_CONFIG)

let configJson =

let config = GenericChart.getConfig gChart

JsonConvert.SerializeObject(config, Globals.JSON_CONFIG)

let displayOpts = GenericChart.getDisplayOptions gChart

let documentTitle =

(displayOpts |> DisplayOptions.getDocumentTitle)

let documentDescription =

(displayOpts |> DisplayOptions.getDocumentDescription)

let documentCharset =

(displayOpts |> DisplayOptions.getDocumentCharset)

let documentFavicon =

(displayOpts |> DisplayOptions.getDocumentFavicon)

let additionalHeadTags =

(displayOpts |> DisplayOptions.getAdditionalHeadTags)

let chartDescription =

(displayOpts |> DisplayOptions.getChartDescription)

let plotlyReference =

displayOpts |> DisplayOptions.getPlotlyReference

HTML.Doc(

documentTitle = documentTitle,

documentDescription = documentDescription,

documentCharset = documentCharset,

documentFavicon = documentFavicon,

chart =

HTML.CreateChartHTML(

data = tracesJson,

layout = layoutJson,

config = configJson,

plotlyReference = plotlyReference

),

plotlyReference = plotlyReference,

AdditionalHeadTags = additionalHeadTags,

ChartDescription = chartDescription

)

|> RenderView.AsString.htmlDocument

/// <summary>

/// Serializes a GenericChart to a JSON string, representing the data and layout of the GenericChart, together with an empty frame array (not supported):

///

/// {

///

/// "data": [ -serialized traces array- ] ,

///

/// "layout": { -serialized layout object- } ,

///

/// "frames": [ -empty array, not supported yet- ]

///

/// }

/// </summary>

/// <param name="gChart">the chart to serialize</param>

static member toFigureJson gChart =

gChart

|> GenericChart.toFigure

|> fun f -> JsonConvert.SerializeObject(f, Globals.JSON_CONFIG)

/// <summary>

/// Serializes a GenericChart to a JSON string, representing the data, layout and config of the GenericChart:

///

/// {

///

/// "data": [ -serialized traces array- ] ,

///

/// "layout": { -serialized layout object- } ,

///

/// "config": { -serialized config object- }

///

/// }

/// </summary>

/// <param name="gChart">the chart to serialize</param>

static member toJson gChart =

gChart

|> GenericChart.toChartDTO

|> fun dto -> JsonConvert.SerializeObject(dto, Globals.JSON_CONFIG)

/// <summary>

/// Creates a new GenericChart whose traces are the results of applying the given function to each trace item of the input GenericChart.

/// </summary>

/// <param name="f">the function to apply to each trace item</param>

/// <param name="gChart">the input GenericChart</param>

static member mapTrace f gChart =

match gChart with

| Chart(trace, layout, config, displayOpts) -> Chart(f trace, layout, config, displayOpts)

| MultiChart(traces, layout, config, displayOpts) ->

MultiChart(traces |> List.map f, layout, config, displayOpts)

/// <summary>

/// Creates a new GenericChart whose traces are the results of applying the given function to each trace item of the input GenericChart.

///

/// The integer index passed to the function indicates the index (from 0) of element being transformed.

/// </summary>

/// <param name="f">the function to apply to each trace item</param>

/// <param name="gChart">the input GenericChart</param>

static member mapiTrace f gChart =

match gChart with

| Chart(trace, layout, config, displayOpts) -> Chart(f 0 trace, layout, config, displayOpts)

| MultiChart(traces, layout, config, displayOpts) ->

MultiChart(traces |> List.mapi f, layout, config, displayOpts)

/// <summary>

/// Returns the number of traces in the given GenericChart.

/// </summary>

/// <param name="gChart">the input GenericChart</param>

static member countTrace gChart =

match gChart with

| Chart(_) -> 1

| MultiChart(traces, _, _, _) -> traces |> Seq.length

/// <summary>

/// Returns true if the given chart contains a trace for which the predicate function returns true

/// </summary>

/// <param name="predicate">the predicate to check for the trace items</param>

/// <param name="gChart">the input GenericChart</param>

static member existsTrace (predicate: Trace -> bool) gChart =

match gChart with

| Chart(trace, _, _, _) -> predicate trace

| MultiChart(traces, _, _, _) -> traces |> List.exists predicate

/// <summary>

/// Creates a GenericChart from a list of trace objects.

///

/// The objects set for the Layout, Config and DisplayOptions depend on `useDefaults`:

///

/// If true, the default objects found in `Defaults` are used.

///

/// If false, empty objects are used.

/// </summary>

/// <param name="useDefaults">wether or not to set default objects for Layout, Config and DisplayOptions</param>

/// <param name="traces">the input Trace collection</param>

static member ofTraceObjects (useDefaults: bool) (traces: #seq<Trace>) = // layout =

let traces = traces |> List.ofSeq

if useDefaults then

// copy default instances so we can safely manipulate the respective objects of the created chart without changing global default objects

let defaultConfig = Config()

Defaults.DefaultConfig.DeepCopyPropertiesTo defaultConfig

let defaultDisplayOpts = DisplayOptions()

Defaults.DefaultDisplayOptions.DeepCopyPropertiesTo defaultDisplayOpts

let defaultTemplate = Template()

Defaults.DefaultTemplate.DeepCopyPropertiesTo defaultTemplate

let defaultLayout =

Layout.init (

Width = Defaults.DefaultWidth,

Height = Defaults.DefaultHeight,

Template = (defaultTemplate :> DynamicObj)

)

if Seq.length traces <> 1 then

GenericChart.MultiChart(

traces,

defaultLayout,

defaultConfig,

defaultDisplayOpts

)

else

GenericChart.Chart(

traces[0],

defaultLayout,

defaultConfig,

defaultDisplayOpts

)

else

if Seq.length traces <> 1 then

GenericChart.MultiChart(traces, Layout(), Config(), DisplayOptions.initCDNOnly ())

else

GenericChart.Chart(traces[0], Layout(), Config(), DisplayOptions.initCDNOnly ())

/// <summary>

/// Creates a GenericChart from a trace object.

///

/// The objects set for the Layout, Config and DisplayOptions depend on `useDefaults`:

///

/// If true, the default objects found in `Defaults` are used.

///

/// If false, empty objects are used.

/// </summary>

/// <param name="useDefaults">wether or not to set default objects for Layout, Config and DisplayOptions</param>

/// <param name="trace">the input Trace</param>

static member ofTraceObject (useDefaults: bool) (trace: Trace) = GenericChart.ofTraceObjects useDefaults (Seq.singleton trace)

/// <summary>

/// Creates a new GenericChart whose layout is the results of applying the given function to the layout of the input GenericChart.

/// </summary>

/// <param name="f">the function to apply to the layout</param>

/// <param name="gChart">the input GenericChart</param>

static member mapLayout f gChart =

match gChart with

| Chart(trace, layout, config, displayOpts) -> Chart(trace, f layout, config, displayOpts)

| MultiChart(traces, layout, config, displayOpts) -> MultiChart(traces, f layout, config, displayOpts)

/// <summary>

/// Creates a new GenericChart whose config is the results of applying the given function to the config of the input GenericChart.

/// </summary>

/// <param name="f">the function to apply to the config</param>

/// <param name="gChart">the input GenericChart</param>

static member mapConfig f gChart =

match gChart with

| Chart(trace, layout, config, displayOpts) -> Chart(trace, layout, f config, displayOpts)

| MultiChart(traces, layout, config, displayOpts) -> MultiChart(traces, layout, f config, displayOpts)

/// <summary>

/// Creates a new GenericChart whose DisplayOptions is the results of applying the given function to the DisplayOptions of the input GenericChart.

/// </summary>

/// <param name="f">the function to apply to the DisplayOptions</param>

/// <param name="gChart">the input GenericChart</param>

static member mapDisplayOptions f gChart =

match gChart with

| Chart(trace, layout, config, displayOpts) -> Chart(trace, layout, config, f displayOpts)

| MultiChart(traces, layout, config, displayOpts) -> MultiChart(traces, layout, config, f displayOpts)

/// <summary>

/// returns a single TraceID (when all traces of the charts are of the same type), or traceID.Multi if the chart contains traces of multiple different types

/// </summary>

/// <param name="gChart">the input genericChart</param>

static member getTraceID gChart =

match gChart with

| Chart(trace, _, _, _) -> TraceID.ofTrace trace

| MultiChart(traces, layout, config, displayOpts) -> TraceID.ofTraces traces

/// <summary>

/// returns a list of TraceIDs representing the types of all traces contained in the chart.

/// </summary>

/// <param name="gChart">the input genericChart</param>

static member getTraceIDs gChart =

match gChart with

| Chart(trace, _, _, _) -> [ TraceID.ofTrace trace ]

| MultiChart(traces, _, _, _) -> traces |> List.map TraceID.ofTrace

and GenericChartFormatter() =

let mutable mimeType = "text/html"

member this.MimeType

with get() = mimeType

and set(v) = mimeType <- v

member this.Format(instance:obj, writer:TextWriter) =

match instance with

| :? GenericChart as c ->

writer.Write("LOL!")

true

| _ -> false

and GenericChartFormatterSource =

member this.CreateTypeFormatters() : seq<obj> =

seq {

yield GenericChartFormatter()

}