module Task7

open System
open System.Collections.Generic

let countFrequencies (lst: 'a list) : ('a * int) list when 'a : equality =
    lst
    |> List.groupBy id
    |> List.map (fun (key, group) -> (key, List.length group))

let findMostFrequent (lst: 'a list) : 'a option when 'a : equality =
    if List.isEmpty lst then
        None
    else
        lst
        |> countFrequencies
        |> List.maxBy snd
        |> fst
        |> Some

let findMostFrequentWithCount (lst: 'a list) : ('a * int) option when 'a : equality =
    if List.isEmpty lst then
        None
    else
        lst
        |> countFrequencies
        |> List.maxBy snd
        |> Some

let findAllMostFrequent (lst: 'a list) : 'a list when 'a : equality =
    if List.isEmpty lst then
        []
    else
        let frequencies = countFrequencies lst
        let maxCount = frequencies |> List.map snd |> List.max
        frequencies
        |> List.filter (fun (_, count) -> count = maxCount)
        |> List.map fst

let getFrequencyStats (lst: 'a list) : Map<'a, int> when 'a : comparison =
    lst
    |> List.groupBy id
    |> List.map (fun (key, group) -> (key, List.length group))
    |> Map.ofList

let findLeastFrequent (lst: 'a list) : 'a option when 'a : equality =
    if List.isEmpty lst then
        None
    else
        lst
        |> countFrequencies
        |> List.minBy snd
        |> fst
        |> Some

let filterByFrequency (minCount: int) (lst: 'a list) : 'a list when 'a : equality =
    let frequencies = countFrequencies lst
    frequencies
    |> List.filter (fun (_, count) -> count >= minCount)
    |> List.collect (fun (element, count) -> List.replicate count element)

let getUniqueElements (lst: 'a list) : 'a list when 'a : equality =
    lst
    |> countFrequencies
    |> List.filter (fun (_, count) -> count = 1)
    |> List.map fst

let removeDuplicates (lst: 'a list) : 'a list when 'a : equality =
    lst |> List.distinct

let sortByFrequency (ascending: bool) (lst: 'a list) : ('a * int) list when 'a : equality =
    let frequencies = countFrequencies lst
    if ascending then
        frequencies |> List.sortBy snd
    else
        frequencies |> List.sortByDescending snd

[<EntryPoint>]
let main argv =
    let testList1 = [1; 2; 3; 2; 4; 2; 5; 3; 2]
    printfn "Test list 1: %A" testList1
    
    match findMostFrequent testList1 with
    | Some element -> printfn "Most frequent element: %A" element
    | None -> printfn "Empty list"
    
    match findMostFrequentWithCount testList1 with
    | Some (element, count) -> printfn "Most frequent: %A appears %d times" element count
    | None -> printfn "Empty list"
    
    let frequencies1 = countFrequencies testList1
    printfn "All frequencies: %A" frequencies1
    
    let testList2 = ["apple"; "banana"; "apple"; "cherry"; "banana"; "apple"]
    printfn "\nTest list 2: %A" testList2
    
    match findMostFrequent testList2 with
    | Some element -> printfn "Most frequent string: %A" element
    | None -> printfn "Empty list"
    
    let allMostFrequent = findAllMostFrequent [1; 2; 2; 3; 3]
    printfn "\nAll most frequent in [1; 2; 2; 3; 3]: %A" allMostFrequent
    
    let stats = getFrequencyStats testList1
    printfn "\nFrequency stats: %A" stats
    
    match findLeastFrequent testList1 with
    | Some element -> printfn "Least frequent element: %A" element
    | None -> printfn "Empty list"
    
    let filtered = filterByFrequency 2 testList1
    printfn "Elements appearing at least 2 times: %A" filtered
    
    let unique = getUniqueElements testList1
    printfn "Unique elements (appearing once): %A" unique
    
    let noDuplicates = removeDuplicates testList1
    printfn "List without duplicates: %A" noDuplicates
    
    let sortedByFreq = sortByFrequency false testList1
    printfn "Sorted by frequency (descending): %A" sortedByFreq
    
    let emptyList = []
    match findMostFrequent emptyList with
    | Some element -> printfn "Should not happen: %A" element
    | None -> printfn "\nEmpty list handled correctly"
    
    0