DoseRule.fs

namespace Informedica.GenForm.Lib


module DoseRule =

    open System
    open MathNet.Numerics
    open FsToolkit.ErrorHandling.ResultCE

    open FSharp.Data
    open FSharp.Data.JsonExtensions

    open Informedica.Utils.Lib
    open Informedica.Utils.Lib.BCL
    open Informedica.GenCore.Lib.Ranges

    open Utils
    open GenFormResult


    module Print =


        open Informedica.GenUnits.Lib

        let printFreqs (r : DoseRule) =
            r.Frequencies
            |> Option.map (fun vu ->
                vu
                |> Utils.ValueUnit.toString 0
            )
            |> Option.defaultValue ""


        let printInterval (dr: DoseRule) =
            if dr.IntervalTime = MinMax.empty then ""
            else
                dr.IntervalTime
                |> MinMax.toString
                    "min. interval "
                    "min. interval "
                    "max. interval "
                    "max. interval "


        let printTime (dr: DoseRule) =
            if dr.AdministrationTime = MinMax.empty then ""
            else
                dr.AdministrationTime
                |> MinMax.toString
                    "min. "
                    "min. "
                    "max. "
                    "max. "


        let printDuration (dr: DoseRule) =
            if dr.Duration = MinMax.empty then ""
            else
                dr.Duration
                |> MinMax.toString
                    "min. duur "
                    "min. duur "
                    "max. duur "
                    "max. duur "


        let printDose wrap (dr : DoseRule) =
            let substDls =
                    dr.ComponentLimits
                    |> Array.collect _.SubstanceLimits

            let formDls =
                dr.ComponentLimits
                |> Array.choose _.Limit

            let useSubstDl = substDls |> Array.length > 0
            // only use form dose limits if there are no substance dose limits
            if useSubstDl then substDls
            else formDls
            |> Array.map (fun dl ->
                let perDose = "/dosis"
                let emptyS = ""
                let printMinMaxDose = DoseLimit.printMinMaxDose ""
                [
                    $"%s{dl.Rate |> printMinMaxDose emptyS}"
                    $"%s{dl.RateAdjust |> printMinMaxDose emptyS}"
                    $"%s{dl.PerTimeAdjust |> printMinMaxDose emptyS}"

                    $"%s{dl.PerTime |> printMinMaxDose emptyS}"
                    $"%s{dl.QuantityAdjust |> printMinMaxDose perDose}"

                    $"%s{dl.Quantity |> printMinMaxDose perDose}"
                ]
                |> List.map String.trim
                |> List.filter (String.IsNullOrEmpty >> not)
                |> String.concat ", "
                |> fun s ->
                    $"%s{dl.DoseLimitTarget |> LimitTarget.toString} %s{wrap}%s{s}{wrap}"
            )


        // get all medications from Kinderformularium
        let kinderFormUrl = "https://www.kinderformularium.nl/geneesmiddelen.json"


        let farmocoTherapeutischKompas = "https://www.farmacotherapeutischkompas.nl/bladeren/preparaatteksten/n/GENERIEK#doseringen"


        let private _medications () =
            let replace =
                [
                    "Ergocalciferol / fytomenadion / retinol / tocoferol (Vitamine A/D/E/K)",
                    "ergocalciferol-fytomenadion-retinol-tocoferol-vitamine-adek"

                    "Natriumdocusaat (al dan niet i.c.m. sorbitol)",
                    "natriumdocusaat-al-dan-niet-icm-sorbitol"
                ]
            let res = JsonValue.Load kinderFormUrl
            [ for v in res do
                {|
                    id = v?id.AsString()
                    generic = v?generic_name.AsString().Trim().ToLower()
                |}
            ]
            |> List.distinct


        let getKFMedications = Memoization.memoize _medications


        let getLink source gen =
            getKFMedications ()
            |> List.tryFind (fun m ->
                m.generic
                |> String.split "+"
                |> List.map String.trim
                |> String.concat "/"
                |> String.equalsCapInsens gen
            )
            |> Option.bind (fun m ->
                let gen = gen |> String.replace "/" "-"
                match source with
                | _ when source = "NKF" ->
                    $"[Kinderformularium](https://www.kinderformularium.nl/geneesmiddel/{m.id}/{gen})"
                    |> Some
                | _ when source = "FK" ->
                    $"[Farmacotherapeutisch Kompas](https://www.farmacotherapeutischkompas.nl/bladeren/preparaatteksten/n/{gen}#doseringen)"
                    |> Some
                | _ -> None
            )


        /// See for use of anonymous record in
        /// fold: https://github.com/dotnet/fsharp/issues/6699
        let toMarkdown (rules : DoseRule array) =
            let generic_md generic =
                $"\n\n# %s{generic}\n\n---\n"

            let route_md route products synonyms =
                if synonyms |> String.isNullOrWhiteSpace then
                    $"\n\n### Route: %s{route}\n\n#### Producten\n%s{products}\n"
                else
                    $"\n\n### Route: %s{route}\n\n#### Producten\n%s{products}\n\n#### Synoniemen\n%s{synonyms}\n"

            let product_md product =  $"* %s{product}"

            let synonyms_md names =
                if names |> Seq.isEmpty then ""
                else
                    let names = names |> String.concat ", "
                    $"* %s{names}"

            let indication_md indication = $"\n\n## Indicatie: %s{indication}\n\n---\n"

            let doseCapt_md = "\n\n#### Doseringen\n\n"

            let dose_md dt dose freqs intv time dur =
                let dt = dt |> DoseType.toDescription
                let freqs =
                    if freqs |> String.isNullOrWhiteSpace then ""
                    else
                        $" in %s{freqs}"

                let s =
                    [
                        if intv |> String.isNullOrWhiteSpace |> not then
                            $" %s{intv}"
                        if time |> String.isNullOrWhiteSpace |> not then
                            $" inloop tijd %s{time}"
                        if dur |> String.isNullOrWhiteSpace |> not then
                            $" %s{dur}"
                    ]
                    |> String.concat ", "
                    |> fun s ->
                        if s |> String.isNullOrWhiteSpace then ""
                        else
                            $" (%s{s |> String.trim})"

                $"* *%s{dt}*: %s{dose}%s{freqs}%s{s}"

            let patient_md patient =
                let patient =
                    if patient |> String.notEmpty then patient
                    else "alle patienten"
                $"\n\n##### Patient: **%s{patient}**\n\n"

            let printDoses (rules : DoseRule array) =
                ("", rules |> Array.groupBy _.DoseType)
                ||> Array.fold (fun acc (dt, ds) ->
                    let pedForm =
                        let link =
                            ds
                            |> Array.tryHead
                            |> Option.bind (fun dr ->
                                dr.Generic |> getLink dr.Source
                            )
                            |> Option.defaultValue "*Lokaal*"

                        ds
                        |> Array.map _.ScheduleText
                        |> Array.distinct
                        |> function
                        | [| s |] -> $"\n\n%s{link}: %s{s}"
                        | _ -> ""

                    ds
                    |> Array.fold (fun acc r ->
                        let dose =
                            r
                            |> printDose ""
                            |> Array.distinct
                            |> String.concat ", "

                        let freqs = r |> printFreqs
                        let intv = r |> printInterval
                        let time = r |> printTime
                        let dur = r |> printDuration

                        let md = dose_md dt dose freqs intv time dur
                        if acc |> String.containsCapsInsens md then acc // prevent duplicate doserule per form print
                        else
                            $"%s{acc}\n%s{md}%s{pedForm}"

                    ) acc
                )

            ({| md = ""; rules = [||] |},
             rules
             |> Array.groupBy _.Generic
            )
            ||> Array.fold (fun acc (generic, rs) ->
                {| acc with
                    md = generic_md generic
                    rules = rs
                |}
                |> fun r ->
                    if r.rules = Array.empty then r
                    else
                        (r, r.rules |> Array.groupBy _.Indication)
                        ||> Array.fold (fun acc (indication, rs) ->
                            {| acc with
                                md = acc.md + (indication_md indication)
                                rules = rs
                            |}
                            |> fun r ->
                                if r.rules = Array.empty then r
                                else
                                    (r, r.rules |> Array.groupBy _.Route)
                                    ||> Array.fold (fun acc (route, rs) ->
                                        let prods =
                                            rs
                                            |> Array.collect _.ComponentLimits
                                            |> Array.collect _.Products
                                            |> Array.sortBy (fun p ->
                                                p.Substances
                                                |> Array.sumBy (fun s ->
                                                    s.Concentration
                                                    |> Option.map ValueUnit.getValue
                                                    |> Option.bind Array.tryHead
                                                    |> Option.defaultValue 0N
                                                )
                                            )
                                            |> Array.map (fun p ->
                                                if p.GPK |> String.IsNullOrWhiteSpace then p.Label
                                                else $"{p.GPK} - {p.Label}"
                                                |> product_md
                                            )
                                            |> Array.distinct
                                            |> String.concat "\n"

                                        let synonyms =
                                            rs
                                            |> Array.collect _.ComponentLimits
                                            |> Array.collect _.Products
                                            |> Array.collect _.Synonyms
                                            |> Array.distinct
                                            |> synonyms_md

                                        {| acc with
                                            md = acc.md + (route_md route prods synonyms)
                                                        + doseCapt_md
                                            rules = rs
                                        |}
                                        |> fun r ->
                                            if r.rules = Array.empty then r
                                            else
                                                (r, r.rules
                                                    |> Array.sortBy (fun d -> d.PatientCategory |> PatientCategory.sortBy)
                                                    |> Array.groupBy _.PatientCategory)
                                                ||> Array.fold (fun acc (pat, rs) ->
                                                    let doses =
                                                        rs
                                                        |> Array.sortBy (fun r -> r.DoseType |> DoseType.sortBy)
                                                        |> printDoses
                                                    let pat = pat |> PatientCategory.toString

                                                    {| acc with
                                                        rules = rs
                                                        md =
                                                            acc.md +
                                                            (patient_md pat) +
                                                            $"\n{doses}"
                                                    |}
                                                )
                                    )
                        )
            )
            |> _.md


        let printGenerics generics (doseRules : DoseRule[]) =
            doseRules
            |> generics
            |> Array.sort
            |> Array.map(fun g ->
                doseRules
                |> Array.filter (fun dr -> dr.Generic = g)
                |> toMarkdown
            )


    open Informedica.GenUnits.Lib

    module GenPresProduct = Informedica.ZIndex.Lib.GenPresProduct
    module GenericProduct = Informedica.ZIndex.Lib.GenericProduct


    /// <summary>
    /// Reconstitute the products in a DoseRule that require reconstitution.
    /// </summary>
    /// <param name="mapping"></param>
    /// <param name="dep">The Department to select the reconstitution</param>
    /// <param name="loc">The VenousAccess location to select the reconstitution</param>
    /// <param name="dr">The DoseRule</param>
    let reconstitute mapping loc dep (dr : DoseRule) =
        let warns = ResizeArray<string>()
        let reconstitute = Product.reconstitute mapping loc dep
        let dr =
            { dr with
                ComponentLimits =
                    dr.ComponentLimits
                    |> Array.map (fun dl ->
                        { dl with
                            Products =
                                dl.Products
                                |> Array.collect (fun prod ->
                                    let prods, newWarns = reconstitute dr.Route prod
                                    warns.AddRange(newWarns)
                                    prods
                                )
                        }
                    )
            }
        dr,
        warns |> Seq.distinct


    let fromTupleInclExcl = MinMax.fromTuple Inclusive Exclusive


    let fromTupleInclIncl = MinMax.fromTuple Inclusive Inclusive


    let mapToDoseRule (r : DoseRuleData) =
        try
            {
                Source = r.Source
                Indication = r.Indication
                Generic = r.Generic
                Form = r.Form
                Brand =
                    if r.Brand |> String.isNullOrWhiteSpace then None
                    else r.Brand |> Some
                Route = r.Route
                ScheduleText = r.ScheduleText
                PatientCategory =
                    {
                        Location = None
                        Department =
                            if r.Department |> String.isNullOrWhiteSpace then None
                            else
                                r.Department |> Some
                        Gender = r.Gender
                        Age =
                            (r.MinAge, r.MaxAge)
                            |> fromTupleInclExcl (Some Utils.Units.day)
                        Weight =
                            (r.MinWeight, r.MaxWeight)
                            |> fromTupleInclExcl (Some Utils.Units.weightGram)
                        BSA =
                            (r.MinBSA, r.MaxBSA)
                            |> fromTupleInclExcl (Some Utils.Units.bsaM2)
                        GestAge =
                            (r.MinGestAge, r.MaxGestAge)
                            |> fromTupleInclExcl (Some Utils.Units.day)
                        PMAge =
                            (r.MinPMAge, r.MaxPMAge)
                            |> fromTupleInclExcl (Some Utils.Units.day)
                        Access = AnyAccess
                    }
                DoseType = r.DoseText |> DoseType.fromString r.DoseType
                AdjustUnit = r.AdjustUnit |> Units.adjustUnit
                Frequencies =
                    match r.FreqUnit |> Units.freqUnit with
                    | None -> None
                    | Some u ->
                        if r.Frequencies |> Array.isEmpty then None
                        else
                            r.Frequencies
                            |> ValueUnit.withUnit u
                            |> Some
                AdministrationTime =
                    (r.MinTime, r.MaxTime)
                    |> fromTupleInclIncl (r.TimeUnit |> Utils.Units.timeUnit)
                IntervalTime =
                    (r.MinInterval, r.MaxInterval)
                    |> fromTupleInclIncl (r.IntervalUnit |> Utils.Units.timeUnit)
                Duration =
                    (r.MinDur, r.MaxDur)
                    |> fromTupleInclIncl (r.DurUnit |> Utils.Units.timeUnit)
                FormLimit = None
                ComponentLimits = [||]
                RenalRule = None
            }
            |> Ok
        with
        | exn ->
            ("mapToDoseRule", Some exn) |> ErrorMsg |> Error


    let getData dataUrlId : GenFormResult<_> =
        try
            Web.getDataFromSheet dataUrlId "DoseRules"
            |> fun data ->
                let getColumn =
                    data
                    |> Array.head
                    |> Csv.getStringColumn

                data
                |> Array.tail
                |> Array.distinctBy (fun row -> row |> Array.tail)
                |> Array.map (fun r ->
                    let get = getColumn r
                    let toBrOpt = BigRational.toBrs >> Array.tryHead

                    {
                        Source = get "Source"
                        Indication = get "Indication"
                        Generic = get "Generic"
                        Form = get "Form"
                        Brand = get "Brand"
                        GPKs =
                            get "GPKs"
                            |> String.splitAt ';'
                            |> Array.map String.trim
                            |> Array.filter String.notEmpty
                            |> Array.distinct
                        Route = get "Route"
                        Department = get "Dep"
                        ScheduleText =
                            try
                                get "ScheduleText"
                            with
                            | _ -> ""
                        Gender = get "Gender" |> Gender.fromString
                        MinAge = get "MinAge" |> toBrOpt
                        MaxAge = get "MaxAge" |> toBrOpt
                        MinWeight = get "MinWeight" |> toBrOpt
                        MaxWeight = get "MaxWeight" |> toBrOpt
                        MinBSA = get "MinBSA" |> toBrOpt
                        MaxBSA = get "MaxBSA" |> toBrOpt
                        MinGestAge = get "MinGestAge" |> toBrOpt
                        MaxGestAge = get "MaxGestAge" |> toBrOpt
                        MinPMAge = get "MinPMAge" |> toBrOpt
                        MaxPMAge = get "MaxPMAge" |> toBrOpt
                        DoseType = get "DoseType"
                        DoseText = get "DoseText"
                        Frequencies = get "Freqs" |> BigRational.toBrs
                        DoseUnit = get "DoseUnit"
                        AdjustUnit = get "AdjustUnit"
                        FreqUnit = get "FreqUnit"
                        RateUnit = get "RateUnit"
                        MinTime = get "MinTime" |> toBrOpt
                        MaxTime = get "MaxTime" |> toBrOpt
                        TimeUnit = get "TimeUnit"
                        MinInterval = get "MinInt" |> toBrOpt
                        MaxInterval = get "MaxInt" |> toBrOpt
                        IntervalUnit = get "IntUnit"
                        MinDur = get "MinDur" |> toBrOpt
                        MaxDur = get "MaxDur" |> toBrOpt
                        DurUnit = get "DurUnit"
                        Component = get "Component"
                        Substance = get "Substance"
                        MinQty = get "MinQty" |> toBrOpt
                        MaxQty = get "MaxQty" |> toBrOpt
                        MinQtyAdj = get "MinQtyAdj" |> toBrOpt
                        MaxQtyAdj = get "MaxQtyAdj" |> toBrOpt
                        MinPerTime = get "MinPerTime" |> toBrOpt
                        MaxPerTime = get "MaxPerTime" |> toBrOpt
                        MinPerTimeAdj = get "MinPerTimeAdj" |> toBrOpt
                        MaxPerTimeAdj = get "MaxPerTimeAdj" |> toBrOpt
                        MinRate = get "MinRate" |> toBrOpt
                        MaxRate = get "MaxRate" |> toBrOpt
                        MinRateAdj = get "MinRateAdj" |> toBrOpt
                        MaxRateAdj = get "MaxRateAdj" |> toBrOpt
                        Products = [||]
                    }
                )
            |> Array.distinct
            |> createOkNoMsgs
        with
        | exn ->
             createError "getDataResult" exn


    let doseRuleDataIsValid (dd: DoseRuleData) =
        match dd.DoseText |> DoseType.fromString dd.DoseType with
        | NoDoseType ->
            // assume an empty dose type is deliberate
            if dd.DoseType |> String.notEmpty then
                $"Not valid dose rule data:\n{dd}\n"
                |> ConsoleWriter.NewLineNoTime.writeWarningMessage
            false
        | Once _ -> true
        | OnceTimed _ ->
            dd.MaxTime.IsSome && dd.TimeUnit |> String.notEmpty
        | Discontinuous _ ->
            dd.Frequencies |> Array.length > 0 && dd.FreqUnit |> String.notEmpty
        | Timed _ ->
            dd.Frequencies |> Array.length > 0 && dd.FreqUnit |> String.notEmpty &&
            dd.MaxTime.IsSome && dd.TimeUnit |> String.notEmpty
        | Continuous _ ->
            dd.RateUnit |> String.notEmpty &&
            (dd.MaxRate.IsSome || dd.MaxRateAdj.IsSome)


    let processDoseRuleData prods routeMapping (data, msgs) : GenFormResult<_> =
        let warnings = Collections.Generic.Dictionary<_, _>()

        let grouped =
            data
            |> Array.filter doseRuleDataIsValid
            |> Array.groupBy (fun d ->
                match d.Form, d.Brand with
                | s, _ when s |> String.notEmpty -> $"{d.Generic} ({d.Form |> String.toLower})"
                | _, s when s |> String.notEmpty -> $"{d.Generic} ({d.Brand |> String.toLower |> String.capitalize})"
                | _ -> d.Generic
                ,
                d.Route
            )

        let procesGroup ((gen: string, rte: string), rs: DoseRuleData[]) =
            async {
                return
                    rs
                    |> Array.collect (fun r ->
                        let filtered =
                            if r.GPKs |> Array.isEmpty then
                                prods
                                |> Product.filter
                                    routeMapping
                                    { Filter.doseFilter with
                                        Generic = r.Component |> Some
                                        Route = rte |> Some
                                    }
                            else
                                prods
                                |> Array.filter (fun p -> r.GPKs |> Array.exists (String.equalsCapInsens p.GPK))

                        if filtered |> Array.length = 0 then
                            let key = $"{gen} {rte}"
                            if warnings.ContainsKey(key) |> not then
                                let msg =
                                    $"{key}: no products found"
                                warnings.Add(key, msg)

                            [|
                                { r with
                                    Products =
                                        [|
                                            rs
                                            |> Array.map _.Substance
                                            |> Array.filter String.notEmpty
                                            |> Array.distinct
                                            |> Product.create gen rte
                                        |]
                                }
                            |]
                        else
                            filtered
                            // create doserule per pharmaceutical form
                            |> Array.groupBy _.Form
                            |> Array.collect (fun (_, ps) ->
                                // make sure that all products have the same unit group
                                ps
                                |> Array.groupBy (_.FormUnit >> ValueUnit.Group.unitToGroup)
                                |> function
                                    | [|_, ps|] ->
                                        ps
                                        |> Array.map (fun product ->
                                            { r with
                                                Generic = gen
                                                Form = product.Form |> String.toLower
                                                Products =
                                                    if r.GPKs |> Array.length > 0 then ps
                                                    else
                                                        ps
                                                        |> Product.filter routeMapping
                                                            { Filter.doseFilter with
                                                                Generic = r.Component |> Some
                                                                Form = product.Form |> Some
                                                                Route = rte |> Some
                                                            }
                                            }
                                        )
                                        |> Array.distinct
                                    | xs ->
                                        xs
                                        |> Array.collect (fun (_, ps) ->
                                            ps
                                            |> Array.map (fun product ->
                                                let u =
                                                    product.FormUnit
                                                    |> Units.toString false Units.Dutch Units.Short

                                                { r with
                                                    Generic = gen
                                                    Form =
                                                        $"{product.Form |> String.toLower} ({u})"
                                                    Products =
                                                        if r.GPKs |> Array.length > 0 then ps
                                                        else
                                                            ps
                                                            |> Product.filter
                                                                routeMapping
                                                                { Filter.doseFilter with
                                                                    Generic = r.Component |> Some
                                                                    Form = product.Form |> Some
                                                                    Route = rte |> Some
                                                                }
                                                }
                                            )
                                            |> Array.distinct
                                        )

                            )

                    )

            }

        let chunkSize = Parallel.totalWorders

        let data =
            grouped
            |> Array.chunkBySize chunkSize
            |> Array.collect (Array.map procesGroup)
            |> Async.Parallel
            |> Async.RunSynchronously
            |> Array.collect id

        let msgs =
            warnings.Values |> Seq.toList
            |> List.map Warning
            |> List.append msgs

        (data, msgs)
        |> Ok


    let addFormLimits routeMapping formRoutes (dr : DoseRule) =
        let prods =
            dr.ComponentLimits
            |> Array.collect _.Products

        let droplets =
            prods
            |> Array.filter (fun p ->
                p.Form |> String.containsCapsInsens "druppel"
            )
            |> Array.choose _.Divisible
            |> Array.distinct
            |> Array.tryExactlyOne

        let setDroplet vu =
            let v, u = vu |> ValueUnit.get
            match droplets with
            | None -> vu
            | Some m ->
                u
                |> Units.Volume.dropletSetDropsPerMl m
                |> ValueUnit.withValue v

        if dr.Form |> String.isNullOrWhiteSpace then dr
        else
            prods
            |> Array.map _.FormUnit
            |> Array.tryExactlyOne
            |> Option.defaultValue NoUnit
            |> Mapping.filterFormRoutes routeMapping formRoutes dr.Route dr.Form
            |> Array.map (fun rsu ->
                { DoseLimit.limit with
                    DoseLimitTarget = OrderableLimitTarget
                    Quantity =
                        {
                            Min = rsu.MinDoseQty |> Option.map Limit.Inclusive
                            Max = rsu.MaxDoseQty |> Option.map Limit.Inclusive
                        }
                    QuantityAdjust =
                        match dr.AdjustUnit with
                        | Some unt when unt |> Units.eqsUnit Units.Weight.kiloGram ->
                            {
                                Min = rsu.MinDoseQtyPerKg |> Option.map Limit.Inclusive
                                Max = rsu.MaxDoseQtyPerKg |> Option.map Limit.Inclusive
                            }
                        | _ -> DoseLimit.limit.QuantityAdjust
                }
                |> fun dl ->
                    if droplets |> Option.isNone then dl
                    else
                        { dl with
                            DoseUnit =
                                droplets
                                |> Option.map Units.Volume.dropletWithDropsPerMl
                                |> Option.defaultValue rsu.DoseUnit
                            Quantity =
                                {
                                    Min =
                                        dl.Quantity.Min
                                        |> Option.map (
                                            Limit.apply
                                                setDroplet
                                                setDroplet
                                        )
                                    Max =
                                        dl.Quantity.Max
                                        |> Option.map (
                                            Limit.apply
                                                setDroplet
                                                setDroplet
                                        )
                                }

                        }
            )
            |> Array.distinct
            |> Array.tryExactlyOne
            |> function
                | None -> dr
                | Some formLimit ->
                    { dr with FormLimit = Some formLimit }


    let getDoseLimits (rs : DoseRuleData []) =
        rs
        |> Array.map (fun r ->
            // the adjust unit
            let adj = r.AdjustUnit |> Utils.Units.adjustUnit
            // the dose unit
            let du = r.DoseUnit |> Units.fromString
            // the adjusted dose unit
            let duAdj =
                match adj, du with
                | Some adj, Some du ->
                    du
                    |> Units.per adj
                    |> Some
                | _ -> None
            // the time unit
            let tu = r.FreqUnit |> Utils.Units.timeUnit
            // the dose unit per time unit
            let duTime =
                match du, tu with
                | Some du, Some tu ->
                    du
                    |> Units.per tu
                    |> Some
                | _ -> None
            // the adjusted dose unit per time unit
            let duAdjTime =
                match duAdj, tu with
                | Some duAdj, Some tu ->
                    duAdj
                    |> Units.per tu
                    |> Some
                | _ -> None
            // the rate unit
            let ru = r.RateUnit |> Units.fromString
            // the dose unit per rate unit
            let duRate =
                match du, ru with
                | Some du, Some ru ->
                    du
                    |> Units.per ru
                    |> Some
                | _ -> None
            // the adjusted dose unit per rate unit
            let duAdjRate =
                match duAdj, ru with
                | Some duAdj, Some ru ->
                    duAdj
                    |> Units.per ru
                    |> Some
                | _ -> None

            {
                DoseLimitTarget =
                    if r.Substance |> String.isNullOrWhiteSpace then
                        r.Component |> ComponentLimitTarget
                    else
                        r.Substance |> SubstanceLimitTarget
                AdjustUnit = adj
                DoseUnit = du |> Option.defaultValue NoUnit
                Quantity =
                    (r.MinQty, r.MaxQty)
                    |> fromTupleInclIncl du
                QuantityAdjust =
                    (r.MinQtyAdj, r.MaxQtyAdj)
                    |> fromTupleInclIncl duAdj
                PerTime =
                    (r.MinPerTime, r.MaxPerTime)
                    |> fromTupleInclIncl duTime
                PerTimeAdjust =
                    (r.MinPerTimeAdj, r.MaxPerTimeAdj)
                    |> fromTupleInclIncl duAdjTime
                Rate =
                    (r.MinRate, r.MaxRate)
                    |> fromTupleInclIncl duRate
                RateAdjust =
                    (r.MinRateAdj, r.MaxRateAdj)
                    |> fromTupleInclIncl duAdjRate
            }
        )


    let addDoseLimits routeMapping formRoutes (rs: DoseRuleData[]) (dr : DoseRule) =
        { dr with
            ComponentLimits =
                rs
                |> Array.groupBy _.Component
                |> Array.map (fun (cmp , rs) ->
                    let lim =
                            rs
                            // if no substance the dose limit is a component limit
                            |> Array.filter (_.Substance >> String.isNullOrWhiteSpace)
                            |> getDoseLimits
                            |> Array.tryExactlyOne

                    {
                        Name = cmp
                        GPKs = rs |> Array.collect _.GPKs
                        Limit = lim
                        Products =
                            rs
                            |> Array.collect _.Products
                            |> Array.filter (fun p ->
                                match lim with
                                | None -> true
                                | Some l ->
                                    l.DoseUnit
                                    |> ValueUnit.Group.eqsGroup Units.Count.times ||
                                    l.DoseUnit
                                    |> ValueUnit.Group.eqsGroup p.FormUnit
                            )
                            |> Array.distinct
                        SubstanceLimits =
                            rs
                            // if a substance the limit is a substance limit
                            |> Array.filter (_.Substance >> String.isNullOrWhiteSpace >> not)
                            |> getDoseLimits
                    }
                )
        }
        |> addFormLimits routeMapping formRoutes


    /// <summary>
    /// Get the DoseRules from the Google Sheet.
    /// </summary>
    /// <remarks>
    /// This function is memoized.
    /// </remarks>
    let get
        dataUrl
        routeMapping
        formRoutes
        prods
        : GenFormResult<_>
        =
        let addDoseLimits = addDoseLimits routeMapping formRoutes

        let map data =
            result {
                let! data, msgs =
                    fun () -> data |> processDoseRuleData prods routeMapping
                    |> StopWatch.clockFunc $"process data {data |> fst |> Array.length}"
                // split in ok and error results
                let rules, errs =
                    fun () ->
                        data
                        |> Array.map (fun d -> d, d |> mapToDoseRule)
                        |> Array.partition (snd >> Result.isOk)
                    |> StopWatch.clockFunc $"map to dose rules {data |> Array.length}"
                // collect all messages
                let msgs =
                    errs
                    |> Array.collect (fun (_, r) ->
                        match r with
                        | Ok _ ->  [||]
                        | Error msg -> [| msg |]
                    )
                    |> Array.toList
                    |> List.append msgs
                // process ok results
                let rules =
                    fun () ->
                        (*
                        rules
                        |> Array.map (fun (d, r) ->
                            r |> Result.get, d
                        )
                        |> Array.groupBy fst
                        |> Array.map (fun (dr, rs) ->
                            dr |> addDoseLimits (rs |> Array.map snd)
                        )
                        *)

                        let chunkBySize = Parallel.totalWorders

                        let grouped =
                            rules
                            |> Array.map (fun (d, r) ->
                                r |> Result.get, d
                            )
                            |> Array.groupBy fst


                        grouped
                        |> Array.chunkBySize chunkBySize
                        |> Array.map (fun rs ->
                            async {
                                return
                                    rs
                                    |> Array.map (fun (dr, rs) ->
                                        dr |> addDoseLimits (rs |> Array.map snd)
                                    )
                            }
                        )
                        |> Async.Parallel
                        |> Async.RunSynchronously
                        |> Array.collect id

                    |> StopWatch.clockFunc $"add dose limits {rules |> Array.length}"

                return! Ok (rules, msgs)
            }

        dataUrl
        |> getData
        |> Result.bind map


    /// <summary>
    /// Filter the DoseRules according to the Filter.
    /// </summary>
    /// <param name="routeMapping"></param>
    /// <param name="filter">The Filter</param>
    /// <param name="drs">The DoseRule array</param>
    let filter routeMapping (filter : DoseFilter) (drs : DoseRule array) =
        // if the filter is 'empty' just return all
        if filter = Filter.doseFilter then drs
        else
            let eqs a b =
                a
                |> Option.map (String.equalsCapInsens b)
                |> Option.defaultValue true

            [|
                fun (dr : DoseRule) -> dr.Indication |> eqs filter.Indication
                fun (dr : DoseRule) -> dr.Generic |> eqs filter.Generic
                fun (dr : DoseRule) -> dr.Form |> eqs filter.Form
                fun (dr : DoseRule) -> filter.Route |> Option.isNone || dr.Route |> Mapping.eqsRoute routeMapping filter.Route
                // don't filter on patients if patient is not set
                if filter.Patient = Patient.patient |> not then
                    fun (dr : DoseRule) -> dr.PatientCategory |> PatientCategory.filter filter
                fun (dr : DoseRule) ->
                    filter.DoseType
                    |> Option.map ((=) dr.DoseType)
                    |> Option.defaultValue true
            |]
            |> Array.fold (fun (acc : DoseRule[]) pred ->
                acc |> Array.filter pred
            ) drs


    let private getMember getter (drs : DoseRule[]) =
        drs
        |> Array.map getter
        |> Array.map String.trim
        |> Array.distinctBy String.toLower
        |> Array.sortBy String.toLower


    /// Extract all indications from the DoseRules.
    let indications = getMember _.Indication


    /// Extract all the generics from the DoseRules.
    let generics = getMember _.Generic


    /// Extract all the pharmaceutical forms from the DoseRules.
    let forms = getMember _.Form


    /// Extract all the routes from the DoseRules.
    let routes = getMember _.Route


    let doseTypes (dsrs : DoseRule []) =
        dsrs
        |> Array.map _.DoseType
        |> Array.distinct


    /// Extract all the departments from the DoseRules.
    let departments = getMember (fun dr -> dr.PatientCategory.Department |> Option.defaultValue "")


    /// Extract all genders from the DoseRules.
    let genders = getMember (fun dr -> dr.PatientCategory.Gender |> Gender.toString)


    /// Extract all patient categories from the DoseRules as strings.
    let patientCategories (drs : DoseRule array) =
        drs
        |> Array.map _.PatientCategory
        |> Array.sortBy PatientCategory.sortBy
        |> Array.map PatientCategory.toString
        |> Array.distinct


    /// Extract all frequencies from the DoseRules as strings.
    let frequencies (drs : DoseRule array) =
        drs
        |> Array.map Print.printFreqs
        |> Array.distinct


    let useAdjust (dr : DoseRule) =
        dr.ComponentLimits
        |> Array.collect _.SubstanceLimits
        |> Array.exists DoseLimit.useAdjust


    let rec getNormDose (dr : DoseRule) =
        dr.ComponentLimits
        |> Array.collect _.SubstanceLimits
        |> Array.collect (fun dl ->
            [|
                match dl.PerTimeAdjust |> DoseLimit.getNormDose with
                | Some norm ->
                    (dl.DoseLimitTarget, norm)
                    |> NormPerTimeAdjust
                    |> Some
                | _ -> None

                match dl.QuantityAdjust |> DoseLimit.getNormDose with
                | Some norm ->
                    (dl.DoseLimitTarget, norm)
                    |> NormQuantityAdjust
                    |> Some
                | _ -> None
            |]
        )
        |> Array.choose id
        |> Array.tryHead


    module DataToCSV =


        let headers =
            [
                "SortNo"
                "Source"
                "Generic"
                "Form"
                "Brand"
                "Route"
                "GPKs"
                "Indication"
                "ScheduleText"
                "Dep"
                "Gender"
                "MinAge"
                "MaxAge"
                "MinWeight"
                "MaxWeight"
                "MinBSA"
                "MaxBSA"
                "MinGestAge"
                "MaxGestAge"
                "MinPMAge"
                "MaxPMAge"
                "DoseType"
                "DoseText"
                "Component"
                "UseGenericName"
                "Substance"
                "Freqs"
                "DoseUnit"
                "AdjustUnit"
                "FreqUnit"
                "RateUnit"
                "MinTime"
                "MaxTime"
                "TimeUnit"
                "MinInt"
                "MaxInt"
                "IntUnit"
                "MinDur"
                "MaxDur"
                "DurUnit"
                "MinQty"
                "MaxQty"
                "NormQtyAdj"
                "MinQtyAdj"
                "MaxQtyAdj"
                "MinPerTime"
                "MaxPerTime"
                "NormPerTimeAdj"
                "MinPerTimeAdj"
                "MaxPerTimeAdj"
                "MinRate"
                "MaxRate"
                "MinRateAdj"
                "MaxRateAdj"
            ]
            |> String.concat "\t"
            |> List.singleton


        let distinctByDoseLimit (d : DoseRuleData) =
                d.DoseType,
                d.Substance |> String.isNullOrWhiteSpace,
                d.AdjustUnit |> String.isNullOrWhiteSpace,
                d.MinQty.IsSome,
                d.MaxQty.IsSome,
                d.MinQtyAdj.IsSome,
                d.MaxQtyAdj.IsSome,
                d.MinPerTime.IsSome,
                d.MaxPerTime.IsSome,
                d.MinPerTimeAdj.IsSome,
                d.MaxPerTimeAdj.IsSome,
                d.MinRate.IsSome,
                d.MaxRate.IsSome,
                d.MinRateAdj.IsSome,
                d.MaxRateAdj.IsSome


        let dataToCsv dataUrlId prods routeMapping distBy =
            let grouped =
                dataUrlId
                |> processDoseRuleData prods routeMapping
                |> Result.toOption
                |> function
                    | None -> [||]
                    | Some (data, _) ->
                        data
                |> Array.groupBy (mapToDoseRule >> Result.toOption)
                |> Array.filter (fst >> Option.isSome)
                |> Array.map (fun (dr, details) -> dr.Value, details)

            let distinct =
                grouped
                |> Array.collect snd
                |> Array.filter (_.Products >> Array.isEmpty >> not)
                |> Array.filter (_.Form >> String.notEmpty)
                |> Array.distinctBy distBy

            grouped
            |> Array.filter (snd >> Array.exists(fun d -> distinct |> Array.exists ((=) d)))
            |> Array.collect snd
            |> Array.toList
            |> List.mapi (fun i d ->
                let bigRatToStringList =
                    Array.map BigRational.toDouble
                    >> Array.map string
                    >> String.concat ";"

                let bigRatOptToString =
                    Option.map (BigRational.toDouble >> string)
                    >> Option.defaultValue ""
                [
                    $"{i}"
                    d.Source
                    d.Generic
                    d.Form
                    d.Brand
                    d.Route
                    d.GPKs |> String.concat ";"
                    d.Indication
                    d.ScheduleText
                    d.Department
                    d.Gender |> Gender.toString
                    d.MinAge |> bigRatOptToString
                    d.MaxAge |> bigRatOptToString
                    d.MinWeight |> bigRatOptToString
                    d.MaxWeight |> bigRatOptToString
                    d.MinBSA |> bigRatOptToString
                    d.MaxBSA |> bigRatOptToString
                    d.MinGestAge |> bigRatOptToString
                    d.MaxGestAge |> bigRatOptToString
                    d.MinPMAge |> bigRatOptToString
                    d.MaxPMAge |> bigRatOptToString
                    d.DoseType
                    d.DoseText
                    d.Component
                    ""
                    d.Substance
                    d.Frequencies |> bigRatToStringList
                    d.DoseUnit
                    d.AdjustUnit
                    d.FreqUnit
                    d.RateUnit
                    d.MinTime |> bigRatOptToString
                    d.MaxTime |> bigRatOptToString
                    d.TimeUnit
                    "" //d.MinInt
                    "" //d.MaxInt
                    "" //d.IntUnit
                    d.MinDur |> bigRatOptToString
                    d.MaxDur |> bigRatOptToString
                    d.DurUnit
                    d.MinQty |> bigRatOptToString
                    d.MaxQty |> bigRatOptToString
                    d.MinQtyAdj |> bigRatOptToString
                    d.MaxQtyAdj |> bigRatOptToString
                    d.MinPerTime |> bigRatOptToString
                    d.MaxPerTime |> bigRatOptToString
                    d.MinPerTimeAdj |> bigRatOptToString
                    d.MaxPerTimeAdj |> bigRatOptToString
                    d.MinRate |> bigRatOptToString
                    d.MaxRate |> bigRatOptToString
                    d.MinRateAdj |> bigRatOptToString
                    d.MaxRateAdj |> bigRatOptToString

                ]
                |> String.concat "\t"
            )
            |> List.append headers