(**************************************************************************
 *                                                                        *
 *  File:        Program.fs                                               *
 *  Copyright:   (c) 2016, Florin Leon                                    *
 *  E-mail:      florin.leon@tuiasi.ro                                    *
 *  Website:     http://florinleon.byethost24.com/lab_ia.htm              *
 *  Description: Records. Function Composition                            *
 *               (Artificial Intelligence lab 4)                          *
 *                                                                        *
 **************************************************************************)
open System

module Program1 =

    let lastButTwo1 (list : 'a list) =
       // cu |>
       list |> List.rev |> List.tail |> List.tail |> List.head

    let lastButTwo2 =
        // cu >>
        let revlist list = List.rev list
        revlist >> List.tail >> List.tail >> List.head

    let mainP1() =
        let list =  [ 1..10 ]
        printfn "Antepenultimul element: %A" (lastButTwo1 list)
        printfn "Antepenultimul element: %A" (lastButTwo2 list)



module Program2 =

//    let selection i (x:float) =
//        if i = 1 then
//            x * 0.9
//        elif i = 2 then
//            x * 0.8

    let discountedSum (list: float list) =
      // daca lista are mai putin de 3 elemente, se face suma simpla
      // altfel: se sorteaza descrescator lista
      // se face o transformare a listei, in care al doilea element este inmultit cu 0.9, al treilea cu 0.8, iar celelalte raman neschimbate
      // se sumeaza elementele

        if list.Length < 3 then
            List.sum list
        else
            list |> List.sortBy(fun x -> -x)  |> List.mapi(fun i x -> if i = 1 then x * 0.9 elif i = 2 then x * 0.8 else x) |> List.sum


    let mainP2() =
        let list = [ 20.0; 10.0; 30.0 ]
        printfn "Preturile articolelor fara reduceri: %A" list
        printfn "Suma fara reduceri: %.2f" (List.sum list)
        printfn "Suma finala: %.2f\n" (discountedSum list)

        let list = [ 10.0; 20.0 ]
        printfn "Preturile articolelor fara reduceri: %A" list
        printfn "Suma fara reduceri: %.2f" (List.sum list)
        printfn "Suma finala: %.2f\n" (discountedSum list)



module Program3 =

    open System
    open System.IO

    let list =
        let lineToTuple (line : string) =
            let toks = line.Split(", ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries)
            (toks.[0], toks.[1], toks.[2])
        File.ReadAllLines "kinship.csv"
        |> List.ofSeq
        |> List.map lineToTuple

    let findParents1() =
        let mothers = List.filter (fun (a, _, _) -> a = "mother") list
        let fathers = List.filter (fun (a, _, _) -> a = "father") list
        [
            for (_, m, c1) in mothers do
                for (_, f, c2) in fathers do
                    if c1 = c2 then
                        yield (m, f, c1)
        ]

    let findParents2() =
        // se filtreaza lista, ramanand numai elementele cu relatiile "mother" sau "father"
        // se transforma aceasta lista intr-o lista de copii
        // se elimina duplicatele: Seq.distinct |> List.ofSeq
        // se transforma lista copiilor intr-o lista de tuple de forma ((getParent c "mother") , (getParent c "father"), c)
        // functia getParent trebuie implementata, folosind functia List.find
        // orice alta abordare functionala este binevenita

        let getparent child parent =
            let (_, b, _) = List.find(fun (a, _, c) -> a = parent && c = child) list
            b

        let mothers = List.filter (fun (a, _, _) -> a = "mother") list
        let fathers = List.filter (fun (a, _, _) -> a = "father") list

        let copii = (List.map( fun (_,_,c) -> c ) mothers) @ (List.map( fun (_,_,c) -> c ) fathers) |> Seq.distinct |> List.ofSeq
        List.map(fun c -> (getparent c "mother", getparent c "father", c)) copii


    let printParents parents =
        List.iteri (fun i (m, f, c) -> printfn "%d. mama %s / tata %s / copilul %s" (i + 1) m f c) parents

    let mainP3() =
        printfn "Metoda imperativa\n"
        findParents1() |> printParents

        printfn "\nMetoda functionala\n"
        findParents2() |> printParents

// ====================================================================

//module Program4 =
//
//    type Person = { Name : string; Children : string list }
//
//    let parents =
//        let vlad = { Name = "Vlad"; Children = ["Oana"; "Mircea"] }
//        let maria = { Name = "Maria"; Children = ["Dan"] }
//        let nelu = { Name = "Nelu"; Children = ["Paul"; "Radu"; "Sorin"] }
//        let liviu = { Name = "Liviu"; Children = ["Vlad"; "Maria"; "Nelu"] }
//        [ liviu; vlad; maria; nelu ]
//
//    let persons =
//        parents
//        |> List.fold (fun acc parent -> List.concat [parent.Name :: acc; parent.Children]) []
//        |> Seq.distinct |> List.ofSeq
//
//    let isParent possibleParent child =
//        // se foloseste functia List.exists si lista parents
//
//    let isCousin c1 c2 =
//        // se incearca gasirea parintilor lui c1 si c2, de exemplu filtrand lista persons => p1, p2
//        // daca c1 sau c2 nu au parinti in lista, sau au acelasi parinte, atunci nu sunt veri
//        // daca p1 si p2 au acelasi parinte, atunci c1 si c2 sunt veri
//
//    let findCousins q =
//        // se filtreaza lista persons dupa predicatul isCousin
//        // orice alta abordare functionala este binevenita
//
//    let mainP4() =
//        let query = "Sorin"
//        printf "Verii lui %s sunt: " query
//        let result = findCousins query
//        printfn "%A" result

// ====================================================================

[<EntryPoint>]
let main argv =
//    Program1.mainP1()
//    Program2.mainP2()
//    Program3.mainP3()
    Program3.mainP3()
    Console.Read()
    0