// bind 5 to x
let x:int = 5

// type inference
let inferredX = 5

// functions are just values, don't need a class
let helloWorld(name) = sprintf "Hello, %s" name 

// type inference again
let text = helloWorld "DNN-Summit"

// Tuples are first class citizens in F#
let person = ("Stefan", 50)
let personShortHand = "Stefan", 50 // string * int
let name, age = personShortHand // decompose the tuple 

// Declaring a record
type Person = { Name : string; Age : int }

// Create an instance
let me = { Name = "Stefan"; Age = 50 }
printfn "%s is %d years old" me.Name me.Age

let a = 10
//a <- 20 // not allowed

let mutable y = 10 // need an extra keyword!
y <- 20 // ok 

let me = { Name = "Stefan"; Age = 50 }
//me.Age <- 20 // not allowed

//creates a new record based on an existing one
let youngerme = {me with Age = 20} 

// Declaring a class
type Person (name:string, age:int)  =
    member val Name = name with get, set //auto properties 
    member val Age  = age  with get, set

let me = Person (Stefan, 50)
me.Age <- 20 // allowed

open FSharp.Data.UnitSystems.SI.UnitSymbols

type Direction = North | South | East | West
type Weather =
    | Cold of temperature:float<C>
    | Sunny
    | Wet
    | Windy of Direction * windspeed:float<m/s>

// Create a weather value
let weather = Windy(North, 10.2<m/s>)

let (|Low|Medium|High|) speed =
    if speed > 10.<m/s> then High
    elif speed > 5<m/s>. then Medium
    else Low

match weather with
| Cold temp when temp < 2.0<C> -> "Really cold!"
| Cold _ | Wet -> "Miserable weather!"
| Sunny -> "Nice weather"
| Windy (North, High) -> "High speed northernly wind!"
| Windy (South, _) -> "Blowing southwards"
| Windy _ -> "It's windy!"

open System
open System.Net

let webPageSize = async {
    use wc = new WebClient()
    let! result = wc.AsyncDownloadString(Uri "http://www.dnn-connect.org")
    return result.Length }

open System
    
let prettyPrintTime() =
    let time = DateTime.UtcNow
    printfn "It is now %d:%d" time.Hour time.Minute

let x = 5
x = 10 // false, COMPARISON!!!

# Install template
dotnet new -i Fable.Template.Elmish.React
# Create  project
dotnet new fable-elmish-react -n awesome
cd awesome
# Install npm dependencies
yarn install
cd src
# Install dotnet dependencies
dotnet restore
# Start Fable server and Webpack dev server
dotnet fable yarn-start
# In your browser, open: http://localhost:8080/

// MODEL

type Model = int

type Msg =
| Increment
| Decrement

let init() : Model = 0

// VIEW

let view model dispatch =
    div []
        [ button [ OnClick (fun _ -> dispatch Decrement) ] [ str "-" ]
          div [] [ str (model.ToString()) ]
          button [ OnClick (fun _ -> dispatch Increment) ] [ str "+" ] ]

// UPDATE

let update (msg:Msg) (model:Model) =
    match msg with
    | Increment -> model + 1
    | Decrement -> model - 1

// wiring things up

Program.mkSimple init update view
|> Program.withConsoleTrace
|> Program.withReact "elmish-app"
|> Program.run

// MODEL

type Model = {
    Counters : Counter.Model list
}

type Msg = 
| Insert
| Remove
| Modify of int * Counter.Msg

let init() : Model =
    { Counters = [] }

// VIEW

let view model dispatch =
    let counterDispatch i msg = dispatch (Modify (i, msg))

    let counters =
        model.Counters
        |> List.mapi (fun i c -> Counter.view c (counterDispatch i)) 
    
    div [] [ 
        yield button [ OnClick (fun _ -> dispatch Remove) ] [  str "Remove" ]
        yield button [ OnClick (fun _ -> dispatch Insert) ] [ str "Add" ] 
        yield! counters ]

// UPDATE

let update (msg:Msg) (model:Model) =
    match msg with
    | Insert ->
        { Counters = Counter.init() :: model.Counters }
    | Remove ->
        { Counters = 
            match model.Counters with
            | [] -> []
            | x :: rest -> rest }
    | Modify (id, counterMsg) ->
        { Counters =
            model.Counters
            |> List.mapi (fun i counterModel -> 
                if i = id then
                    Counter.update counterMsg counterModel
                else
                    counterModel) }

[AntiForgeryToken: {}]   
[JavaScript:{ 
   path: "http://localhost:8080/bundle.js", 
   provider:"DnnFormBottomProvider"}]
<div id="elmish-todo" data-moduleId = "[ModuleContext:ModuleId]"></div>

[AntiForgeryToken: {}]   
[JavaScript:{path: "http://localhost:8080/bundle.js", provider:"DnnFormBottomProvider"}]
<div class="elmish-module" data-moduleId = "[ModuleContext:ModuleId]"></div>

let runApp elementId =
    Program.mkSimple init update view
    |> Program.withReact elementId
    |> Program.run

let runApps className =
    let elements = document.getElementsByClassName className
    let runOnElement index  =
         let elementId =  sprintf "%s-%i" className index
         elements.[index].id <- elementId
         runApp elementId
    Seq.iter (runOnElement) [0 .. int elements.length - 1]

runApps "elmish-module"

  module.exports = {
  devtool: "source-map",
  entry: resolve('./src/elmish.fsproj'),
  output: {
    filename: 'bundle.js',
    path: resolve('./public'),
    publicPath: 'http://localhost:8080/',
  },
  devServer: {
    contentBase: resolve('./public'),
    headers: { "Access-Control-Allow-Origin": "*" },
    port: 8080,
    hot: true,
    inline: true
  },
  ...

open Fable.Core

type IServicesFramework = 
  abstract getServiceRoot: string     -> string 
  abstract setModuleHeaders: obj      -> unit
  abstract getTabId : unit            -> int option
  abstract getModuleId : unit         -> int option 
  abstract getAntiForgeryValue : unit -> string option
  

[<Emit("window['$'].ServicesFramework($0)")>]
let ServiceFramework (moduleid:int) : IServicesFramework  = jsNative

type FableConfigAttribute () =
  inherit System.Attribute()

  interface IControllerConfiguration with
    member __.Initialize ((controllerSettings:HttpControllerSettings), _) =
        let fableFormatter = 
           JsonMediaTypeFormatter ( 
             SerializerSettings = JsonSerializerSettings (
                Converters = [|Fable.JsonConverter()|]))
        controllerSettings.Formatters.Clear ()
        controllerSettings.Formatters.Add fableFormatter

[<FableConfig>]
type FableController () =
  inherit DnnApiController ()