Worm War 2

open System

type Network = {id:char; hosts:int; infected:int  }

type Link = { n1:char; n2:char; capacity:int }

type Rate = {S:float ; I:float; R:float}

//Natural number
let (|Nat|_|) str =
   match System.Int32.TryParse(str) with
   | (true,int) when int > 0 -> Some(int)
   | _ -> None
//Integer greater then 0
let (|ZeroNAT|_|) str =
   match System.Int32.TryParse(str) with
   | (true,int) when int >= 0 -> Some(int)
   | _ -> None

let (|Float|_|) str =
    match Double.TryParse(str) with
    | (true,v)  when v > 0.0 ->  Some(v)
    | _ -> None

let (|Char|_|) (str:string) =
    match str |> String.length with
    | 1 -> Some (str |> Seq.head)
    | _ -> None

let getNumberItems () =
    match Console.ReadLine() with
    | Nat v -> Ok v
    | _ -> Error "invalid number, must be greater then 0"
let tryRead() =
    match Console.ReadLine() with
    | null -> Error "not Expecting empty input"
    | v -> Ok v
let maybeNetwork (str:string) =
    match str.Split(' ', StringSplitOptions.RemoveEmptyEntries) with
    | [|Char c; Nat h; ZeroNAT i |] -> Ok {id = c; hosts = h; infected = i }
    | _ -> Error "Invalid network"
let maybeLink (str:string) =
   match str.Split(' ', StringSplitOptions.RemoveEmptyEntries) with
   | [|Char c1; Char c2; Nat cap  |] -> Ok { n1=c1; n2=c2; capacity= cap}
   | _ -> Error "Invalid Link"

let maybeRate (str:string) =
    match str.Split(' ', StringSplitOptions.RemoveEmptyEntries) with
    | [|Float spread; Float infected; Float rate |] -> Ok {S = spread; I = infected; R = rate;}
    | _ -> Error "Invalid Rate"

let getNetworks n =
    //Some kind of sequence or list to replace this?
   let rec tryNewnetwork lis =

       printfn "enter network ID(char) hosts(integer greater then 0 ) infected(integer greater then 0)"
       tryRead()
       |> Result.bind(maybeNetwork)
       |> Result.bind(fun x -> if not ( lis |> List.exists(fun y -> x.id = y.id)) then Ok x else Error "A network with that ID already exists")
       |>function
       | Ok  newNet -> match (newNet::lis) |> List.length with
                        | v when v = n -> lis
                        | _ -> tryNewnetwork lis
       | Error e ->  printfn "%s" e
                     tryNewnetwork lis
   tryNewnetwork []

let identicalLink l1 l2 =
    ((l1.n1 = l2.n1 && l1.n2 = l2.n2 )||(l1.n1 = l2.n2 && l1.n2 = l2.n1))

let linkHasNetworks networkLis l1  =
    List.exists(fun y -> l1.n1 = y.id) networkLis && List.exists(fun y -> l1.n2 = y.id) networkLis

let getLinks n networkLis =
     //Some kind of sequence or list to replace this?
   let rec trylistofLinks lis =
       tryRead()
       |> Result.bind(maybeLink)
       |> Result.bind(fun x -> match x.n1 = x.n2 with
                              | false -> Ok x
                              | true -> Error "can't connect to the same network")
       |> Result.bind(fun x -> if not ( lis |> List.exists(fun y -> identicalLink x y )) then Ok x else Error "A Link connecting these two networks already exists")
       |> Result.bind(fun x ->  match linkHasNetworks networkLis x with
                               | true -> Ok x
                               | false -> Error "Both networks need to exist")
       |>function
       | Ok  newNet -> match (newNet::lis) |> List.length with
                        | v when v = n -> lis
                        | _ -> trylistofLinks lis
       | Error e ->  printfn "%s" e
                     trylistofLinks lis
   trylistofLinks []

let getRate () =
    tryRead() |>
    Result.bind maybeRate

let simulate = ignore

[<EntryPoint>]
let main argv =
    printfn "Enter Number of networks"
    getNumberItems()
    |> Result.map(fun x ->  getNetworks x)
    |> function //output
    | Ok result -> result
                   |> printfn "%A"
    | Error e -> printfn "%s" e
    0 // return an integer exit code