type Shape =
| Square of edge : float
// `*` in type declarations stands for tuples
| Rectangle of width : float * height : float
| Circle of radius : float

type Tree =
| Empty
| Node of value: int * left: Tree * right: Tree

let tree =
    Node (8, 
     Node (3, 
      Node (1, Empty, Empty), 
      Node (6,
       Node (4, Empty, Empty), 
       Node (7, Empty, Empty))),
     Node (10, 
      Empty,
      Node (14, 
       Node (13, Empty, Empty), 
       Empty)))

printf "This is what a tree looks like: %A" tree

let sprintfResult = sprintf "%A" tree

let rec countInternal (tree: Tree) : int =
    match tree with
    | Empty -> 0
    | Node (_, Empty, Empty) -> 0
    | Node (_, left, right) -> 
        1 + countInternal left + countInternal right

let ``example 1.1`` = countInternal tree

let rec sumLeaves (tree: Tree) : int = 
    0

let ``exercise 1.1`` = sumLeaves tree

let firstList = [1;3;5]
let secondList = [2 .. 10]
let concatenatedList = firstList @ secondList

let rec collectLeaves (tree : Tree) : list<int> =
    match tree with
    | Empty -> []
    | Node (v, Empty, Empty) -> [v]
    | Node (_, left, right) -> 
        collectLeaves left @ collectLeaves right

let ``example 1.2`` = collectLeaves tree

let rec collectInOrder (tree : Tree) : list<int> =
    []

let ``exercise 1.2`` = collectInOrder tree

let isSorted (tree: Tree) : bool =
    false

let ``exercise 1.3`` = isSorted tree

let rec incrementValues (tree: Tree) : Tree =
    match tree with
    | Empty -> Empty
    | Node (v, left, right) ->
        Node (v + 1, incrementValues left, incrementValues right)

let ``example 1.4`` = incrementValues tree |> collectInOrder

let rec insertBST (value: int) (tree: Tree) : Tree =
    Empty

let ``exercise 1.4`` = insertBST 5 tree |> collectInOrder

type Figure = 
    | Two  | Three | Four  | Five 
    | Six  | Seven | Eight | Nine 
    | Ten  | Jack  | Queen | King | Ace

type Suit = Diamonds | Spades | Hearts | Clubs

// Type alias for a tuple
type Card = Figure * Suit

// Type alias for a list
type Hand = list<Card>

let oddNumbers =
    [1 .. 10]
    |> List.filter (fun n -> n % 2 = 1)

let kingSpades = King, Spades
let (figure, suit) = kingSpades
let isKingSpades = 
    match kingSpades with
    | King, Spades -> true
    | _ -> false

let queenHearts = Queen, Hearts
let queen = fst queenHearts
let hearts = snd queenHearts

let threeKings = 
    [King, Clubs
     King, Diamonds
     King, Hearts]

let ``example 2.1`` = 
    threeKings
    |> List.forall (fun (figure,suit) -> figure = King)

let handFlush = [King,Clubs;Queen,Clubs;Nine,Clubs;Eight,Clubs;Five,Clubs]

let isFlush (hand: Hand) : bool =
    false

let ``exercise 2.1`` = isFlush handFlush

let mapModThree =
    [1 .. 10]
    |> List.map (fun n -> n % 3 = 0)

let groupModThree =
    [1 .. 10]
    |> List.groupBy (fun n -> n % 3)

let ``example 2.2`` = 
    ["Ananas";"Banan";"Agrest";"Cukinia";"Cebula";"Aronia"]
    |> List.groupBy (fun word -> word.ToCharArray().[0])
    |> List.map (fun (letter,words) -> (letter,words.Length))

let handFullHouse = [King,Clubs;King,Spades;Nine,Clubs;Nine,Diamonds;Nine,Spades]

let isFullHouse (hand: Hand) : bool =
    false

let ``exercise 2.2`` = isFullHouse handFullHouse

type Point =
  { X : float 
    Y : float }

type CenteredShape =
  { Shape : Shape 
    Center : Point }

let point = { X = 2.0; Y = 4.5 }
let shape = { Shape = Square 3.0; Center = point }

let pointX = point.X
let shapeField = shape.Shape

let shapesAreEqual = 
    shape = { Shape = Square 3.0; Center = point }

let forthAndBack =
    [ 1.0 .. 10.0 ]
    |> List.map (fun x -> x ** 2.0)
    |> List.map (fun x -> sqrt x)

let withCenterIn point shapes =
    shapes
    |> List.filter (fun shape -> shape.Center = point)

let ``example 2.3`` =
    [{ Shape = Circle (sqrt 2.0); Center = { X = 0.0; Y = 0.0 }}
     { Shape = Square 2.0;        Center = { X = 0.0; Y = 0.0 }}
     { Shape = Rectangle (3.,4.); Center = { X = 0.0; Y = 1.0 }}]
    |> withCenterIn { X = 0.0; Y = 0.0 }

let isCircumcircle 
    (centeredCircle: CenteredShape) 
    (centeredShape:  CenteredShape) 
    : bool = 
    false

let ``exercise 2.3`` = 
    [({ Shape = Circle (sqrt 2.0); Center = { X = 0.0; Y = 0.0 }},
      { Shape = Square 2.0;        Center = { X = 0.0; Y = 0.0 }})

     ({ Shape = Circle (sqrt 2.0); Center = { X = 1.0; Y = 0.0 }},
      { Shape = Square 2.0;        Center = { X = 0.0; Y = 0.0 }})

     ({ Shape = Circle 2.5;        Center = { X = 0.0; Y = 0.0 }},
      { Shape = Rectangle (3.,4.); Center = { X = 0.0; Y = 0.0 }})

     ({ Shape = Circle 2.5;        Center = { X = 0.0; Y = 0.0 }},
      { Shape = Rectangle (3.,4.); Center = { X = 0.0; Y = 1.0 }})]
    |> List.map (fun (first,second) -> isCircumcircle first second)

let zeroSquare = { Shape = Square 2.0; Center = { X = 0.0; Y = 0.0 } }

let squareMoved =
    { zeroSquare with Center = { X = 2.0; Y = 1.0 } }

let circleWithSameCenter =
    { zeroSquare with Shape = Circle 3.0 }

let translate (vectorPoint: Point) (shape: CenteredShape) : CenteredShape =
    { shape with Center = 
                 { X = shape.Center.X + vectorPoint.X; 
                   Y = shape.Center.Y + vectorPoint.Y }}

let ``example 2.4`` = 
    [{ Shape = Circle (sqrt 2.0); Center = { X = 0.0; Y = 0.0 }}
     { Shape = Square 2.0;        Center = { X = 0.0; Y = 3.0 }}
     { Shape = Rectangle (3.,4.); Center = { X = 0.0; Y = 1.0 }}]
    |> List.map (translate { X = -2.0; Y = -3.0 })

let scale (magnitude: float) (centeredShape: CenteredShape) : CenteredShape  = 
    centeredShape

let ``exercise 2.4`` = 
    [{ Shape = Circle (sqrt 2.0); Center = { X = 0.0; Y = 0.0 }}
     { Shape = Square 1.0;        Center = { X = 0.0; Y = 3.0 }}
     { Shape = Rectangle (3.,4.); Center = { X = 0.0; Y = 1.0 }}]
    |> List.map (scale 2.0)

"XXXXXXXXXXXX" // 12 rolls: 12 strikes
10+10+10 + 10+10+10 + 10+10+10 + 10+10+10 + 10+10+10 + ... = 300

"9-9-9-9-9-9-9-9-9-9-" // 20 rolls: 10 pairs of 9 and miss
9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 + 9 = 90

"5/5/5/5/5/5/5/5/5/5/5" // 21 rolls: 10 pairs of 5 and spare, with a final 5
10+5 + 10+5 + 10+5 + 10+5 + 10+5 + ... = 150

"X9/5/72XXX9-8/9/X"
10+9+1  + 9+1+5  + 5+5+7 + 7+2   + 10+10+10 + 
10+10+9 + 10+9+0 + 9+0   + 8+2+9 + 9+1+10   = 187

"X4/2-" // What is the score?

let (|Digit|_|) char =
    let zero = System.Convert.ToInt32 '0'
    if System.Char.IsDigit char then
        Some (System.Convert.ToInt32 char - zero)
    else
        None

let digit = 
    match '5' with
    | Digit x -> "a digit " + x.ToString()
    | _ -> "not a digit"

let rec matchNext5 list =
    match list with
    | [] -> []
    | x :: 5 :: rest -> 0 :: 5 :: matchNext5 rest
    | x :: rest -> x :: matchNext5 rest

let ``example 3.1`` = 
    matchNext5 [1..10]

let rec parseScore (chars: list<char>) : list<Option<int>> =
    []

let ``exercise 3.1`` = parseScore ['X';'4';'/';'2';'-';'N']

let onlyEvenNumber optNumber =
    match optNumber with
    | Some n when n % 2 = 0 -> "ok"
    | _ -> "wrong"
    
let onlyEvenNumbers =
    [Some 2; Some 3; Some 4; Some 5; None]
    |> List.map onlyEvenNumber

let rec numTriangle numbers =
    match numbers with
    | first :: (second :: _ as rest) ->
        first + second :: numTriangle rest
    | _ ->
        []

let triangle = numTriangle [1 .. 5]

let rec countScore (scores: list<int>) : int =
    0

let ``exercise 3.2`` = 
    [[10;10;10;10;10;10;10;10;10;10;10;10]
     [9;0;9;0;9;0;9;0;9;0;9;0;9;0;9;0;9;0;9;0]
     [5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5;5]
     [10;9;1;5;5;7;2;10;10;10;9;0;8;2;9;1;10]]
    |> List.map countScore 

let bowlingScore (score: string) : Option<int> =
    Some 0

let ``homework 1`` = 
    ["XXXXXXXXXXXX" 
     "9-9-9-9-9-9-9-9-9-9-" 
     "5/5/5/5/5/5/5/5/5/5/5"
     "X9/5/72XXX9-8/9/X" ] |> List.map bowlingScore

let rec parseScoreTail 
            (chars: list<char>) 
            (acc : list<Option<int>>) 
            : list<Option<int>> =
    []

let rec countScoreTail (scores: list<int>) (acc : int) : int =
    0

let bowlingScoreTail (score: string) : Option<int> =
    Some 0

let ``homework 2`` = bowlingScoreTail "XXXXXXXXXXXX"