F# Żywność

open System

//Przy funkcjach napisane są typy parametrów i wyniku funkcji
//Na zaliczeniu nie jest to konieczne

//typ pozwalający zapisać ilość:
// wody
// tłuszczu (w tym utwardzonego)
// węglowowanów (w tym cukrów)
// białka
// błonnika

type nutr_el =
    | Woda of float
    | Tluszcz of float*float
    | Weglowowany of float*float
    | Bialko of float
    | Blonnik of float

type nutr = nutr_el list

//Wczytaj dane od użytkownika, zwróć skład produktu
let wczytaj(unit):nutr option =
    let input = System.Console.ReadLine()
    let array = input.Split(',')

    if array.Length = 7 then let mutable woda = 1.0
                             let mutable tluszcz1 = 1.0
                             let mutable tluszcz2 = 1.0
                             let mutable weglowowany1 = 1.0
                             let mutable weglowowany2 = 1.0
                             let mutable bialko = 1.0
                             let mutable blonnik = 1.0
                             if Double.TryParse(array.[0],&woda) &&
                                Double.TryParse(array.[1],&tluszcz1) &&
                                Double.TryParse(array.[2],&tluszcz2) &&
                                Double.TryParse(array.[3],&weglowowany1) &&
                                Double.TryParse(array.[4],&weglowowany2) &&
                                Double.TryParse(array.[5],&bialko) &&
                                Double.TryParse(array.[6],&blonnik)
                                then Some [Woda woda;
                                           Tluszcz (tluszcz1,tluszcz2);
                                           Weglowowany (weglowowany1,weglowowany2);
                                           Bialko bialko;
                                           Blonnik blonnik]
                                else None
                        else None

//Zsumuj cały skład
//Jeśli suma < 100%, zwróć % zatajonych składników
//Jeśli suma > 100%, skład jest niepoprawny
let zweryfikuj (sklad:nutr):unit =
    //funkcja sumująca skład
    let rec suma(s:nutr):float =
        match s with
        | head::tail -> match head with
                        | Woda w -> w + suma tail
                        | Tluszcz (t,_) -> t + suma tail
                        | Weglowowany (w,_) -> w + suma tail
                        | Bialko b -> b + suma tail
                        | Blonnik b -> b + suma tail
        | [] -> 0.0

    let s = (suma sklad)
    let wynik = 100.0 - s
    if wynik > 0.0 then printfn "Utajony skład: %f%%" (wynik)
        elif wynik < 0.0 then printfn "Niepoprawny skład"
            else printfn "Poprawny skład"

//Korzystając z funkcji z zadania 2 (wczytującą skład z inputu użytkownika)
//Wywołuj tą funkcję do momentu gdy funkcja zwróci wartość None
//Zwróć listę składów

let rec zad4(unit):nutr list =
    match wczytaj() with
    | Some s -> s::(zad4())
    | None -> []

//zwróć składnik, którego jest najwięcej
//Wariant A - jeśli są dwa takie składniki, zwraca pierwszy jaki napotka
let znajdzMax1(list:nutr):nutr_el =
    List.maxBy (fun x -> match x with
                         | Woda w -> w
                         | Tluszcz (t,_) -> t
                         | Weglowowany (w,_) -> w
                         | Bialko b -> b
                         | Blonnik b -> b) list

//Wariant B -> zwraca listę takich elementów
//nutr_el list jest równe nutr
let znajdzMax2(sklad:nutr):nutr_el list =
    //matchowanie jest tutaj niekonieczne, ponieważ wiemy, że lista ma pięć elementów i znamy ich kolejność
    //ale to jest uniwersalne rozwiązanie, które działa też w przypadkach, gdzie elementy listy mogą się powtarzać
    let rec znajdzMax2Helper1(s:nutr) (a,b,c,d,e) =
        match s with
        | head::tail -> match head with
                        | Woda x ->             znajdzMax2Helper1 tail (a+x,b,c,d,e)
                        | Tluszcz (x,_) ->      znajdzMax2Helper1 tail (a,b+x,c,d,e)
                        | Weglowowany (x,_) ->  znajdzMax2Helper1 tail (a,b,c+x,d,e)
                        | Bialko x ->           znajdzMax2Helper1 tail (a,b,c,d+x,e)
                        | Blonnik x ->          znajdzMax2Helper1 tail (a,b,c,d,e+x)
        | [] -> (a,b,c,d,e)

    // bez określenia typów parametrów funkcji, kompilator nie wie jaką wersję funkcji Max ma użyć
    let znajdzMax2Helper2 (a:float,b:float,c:float,d:float,e:float):float =
        Math.Max(Math.Max(Math.Max(a,b),c),Math.Max(d,e))

    let rec znajdzMax2Helper3 (s:nutr) (max:float) =
        match s with
        | head::tail -> match head with
                        | Woda x when x=max->              head::znajdzMax2Helper3 tail max
                        | Tluszcz (x,_) when x=max ->      head::znajdzMax2Helper3 tail max
                        | Weglowowany (x,_) when x=max ->  head::znajdzMax2Helper3 tail max
                        | Bialko x when x=max ->           head::znajdzMax2Helper3 tail max
                        | Blonnik x when x=max ->          head::znajdzMax2Helper3 tail max
                        | _ -> znajdzMax2Helper3 tail max
        | [] -> []

    let krotka = znajdzMax2Helper1 sklad (0.0,0.0,0.0,0.0,0.0)
    let max = znajdzMax2Helper2 krotka
    znajdzMax2Helper3 sklad max



[<EntryPoint>]
let main argv =
    let result = wczytaj()
    match result with
    | Some s -> zweryfikuj s
                printfn "%A" <| znajdzMax2 s
    | None -> ()

    ignore <| System.Console.ReadLine()
    0 // return an integer exit code