// For more information see https://aka.ms/fsharp-console-apps
printfn "Hello from F#"

// Learn more about F# at http://docs.microsoft.com/dotnet/fsharp

open System

// Define a function to construct a message to print
let from whom =
    sprintf "from %s" whom

[<EntryPoint>]
let main argv =
    let message = from "F#" // Call the function
    printfn "Hello world %s" message
    0 // return an integer exit code

let userInput = 
    let args = System.Environment.GetCommandLineArgs()      // first argument will always be the filepath to the executable
    Array.skip 1 args

printfn "Hello from F# with userInput: %A" userInput

open System

let from whom =
    sprintf "from %s" whom

[<EntryPoint>]
let main argv =     // `argv` will always exclude the filepath to the executable
    let message = from "F#"
    printfn "Hello %s with userInput: %A" message argv
    0

// we start with a simple build
let publishBinariesWin = BuildTask.create "PublishBinariesWin" [clean.IfNeeded; build.IfNeeded] {
    let outputPath = sprintf "%s/win-x64" publishDir
    solutionFile
    |> DotNet.publish (fun p ->
        // and then call MSBuild to run with the arguments we parse into it:
        let standardParams = Fake.DotNet.MSBuild.CliArguments.Create ()
        {
            p with
                // set some of the properties...
                Runtime = Some "win-x64"
                Configuration = DotNet.BuildConfiguration.fromString configuration
                OutputPath = Some outputPath
                MSBuildParams = {
                    standardParams with
                        Properties = [      // here you can set all the properties that were not treated before
                            "Version", stableVersionTag
                            "Platform", "x64"
                            "PublishSingleFile", "true"
                        ]
                };
        }
    )
}

#r "nuget: Argu, 6.1.1"

open Argu

// Union type for a kind of command
type MainCommands =
    // each field is a command. Specific properties are realized via attributes
    | [<CliPrefix(CliPrefix.None)>]                         PrintHWFs
    | [<CliPrefix(CliPrefix.None)>]                         PrintHWfrom     of person : string
    // the `ParseResults<yourType>` type makes subcommands possible (see below)
    | [<CliPrefix(CliPrefix.None)>][<AltCommandLine("-e")>] PrintHWextended of ParseResults<SubCommands>
    // the `IArgParserTemplates` allows for adding usage descriptions which are shown when calling `--help` or giving a wrong input argument
    interface IArgParserTemplate with
        member this.Usage =
            match this with
            | PrintHWFs         -> "Print Hello World"
            | PrintHWfrom _     -> "Print Hello World from someone"
            | PrintHWextended _ -> "Print Hello World from someone to someone"

and SubCommands =
    | To       of person : string
    | FromTo   of sender : string * receiver : string
    interface IArgParserTemplate with
        member this.Usage =
            match this with
            | To _      -> "Receiver of the message"
            | FromTo _  -> "Sender and receiver of the message"

// initialization of the parser
let parser = ArgumentParser.Create<MainCommands>()

[<EntryPoint>]
let main argv =
    try 
        // parse the user's command-line arguments
        let pr = parser.ParseCommandLine(inputs = argv, raiseOnUsage = true)
        // return the results
        let ar = pr.GetAllResults()
        // this is the actual control flow: What shall happen if the user gives what argument, what second argument, and so on
        match ar.Length with
        | 0 -> printfn "No input."
        | _ ->
            ar
            |> List.iter (
                fun r ->
                    match r with
                    | PrintHWFs         -> printfn "Hello World from F#!"
                    | PrintHWfrom p     -> printfn $"Hello World from {p}!"
                    | PrintHWextended p ->
                        p.GetAllResults()
                        |> List.iter (
                            fun r2 ->
                                match r2 with
                                | To p2             -> printfn $"Hello World from F# to {p2}!"
                                | FromTo (p2,p3)    -> printfn $"Hello World from {p2} to {p3}!"
                        )
            )
    with e -> printfn "%A" e
    0

#r "nuget: Spectre.Console, 0.43.0"
#r "nuget: FSharpAux, 1.1.0"

open System
open System.IO
open System.Threading
open Spectre.Console
open FSharpAux

[<EntryPoint>]
let main _ =

    // a test file for our purposes
    let table =
        let file = File.ReadAllLines(Path.Combine("c:", "testFolder", "table.tsv"))
        file
        |> Array.map (
            fun s -> s.Split('\t')
        )
        |> array2D

    // initialize a new table and set the border style
    let spectreTable = new Table()
    spectreTable.Border <- TableBorder.HeavyHead

    let cols = table[0,0 ..]
    let rows = table[1 ..,0 ..]

    // apply some markup to our strings
    let markupdCols = cols |> Array.map (fun s -> ($"[bold][italic]{s}[/][/]"))
    let markupdRows = 
        rows
        |> Array2D.mapColI (
            fun iCol s ->
                if iCol = 4 then
                    match int s with
                    | x when x > 80     -> $"[red]{s}[/]"
                    | x when x <= 80    -> $"[green]{s}[/]"
                    | _                 -> failwith "cannot happen"
                else s
        )

    // add columns and rows to the table
    spectreTable.AddColumns(markupdCols) |> ignore
    for i = 0 to rows.GetLength(0) - 1 do
        spectreTable.AddRow(markupdRows.[i,0 ..])
        |> ignore

    spectreTable.Title <- TableTitle("Musterpeople")

    // display the table
    AnsiConsole.Write(spectreTable)

type Dir = {
    Name    : string
    Subdirs : Dir []
    Files   : FileInfo []
}

[<EntryPoint>]
let main _ =

    // special markup for special files
    let matchFileExt f =
        match f with
        | x when String.contains(".jpg") x -> $"[orange1]{f}[/]"
        | x when String.contains(".png") x -> $"[gold1]{f}[/]"
        | x when String.contains(".txt") x -> f
        | x when String.contains(".xlsx") x -> $"[green]{f}[/]"
        | x when String.contains(".pub") x -> $"[darkslategray3]{f}[/]"
        | x when String.contains(".rtf") x -> $"[blue]{f}[/]"
        | _ -> f

    let rec constructDir path = {
        Name    = (DirectoryInfo path).Name
        Files   = Directory.GetFiles(path) |> Array.map FileInfo
        Subdirs = 
            Directory.GetDirectories(path)
            |> Array.map constructDir
    }

    let topDir = constructDir @"C:\testFolder\testDir"

    // add a node with every new file and folder but only check folders for files and subfolders
    let rec addNode (node : TreeNode) dir =
        dir.Subdirs |> Array.map (fun di -> addNode (node.AddNode(di.Name)) di) |> ignore
        dir.Files |> Array.map (fun fi -> node.AddNode(fi.Name |> matchFileExt)) |> ignore
        node

    // initialize tree and style it
    let root = Tree(topDir.Name)
    root.Style <- Style(Color.Red1)
    root.Guide <- TreeGuide.Line
    // add the nodes
    root.AddNodes(topDir.Files |> Array.map (fun fi -> fi.Name |> matchFileExt))
    topDir.Subdirs 
    |> Array.map (
        fun di ->
            addNode (root.AddNode(di.Name)) di
    )
    |> ignore

    AnsiConsole.Write(root)

[<EntryPoint>]
let main _ =

    let noOfContributionsIn2021 =
        [|("muehlhaus", 158); ("geodels", 0); ("MikhayN", 0); ("HLWeil", 463);
        ("ZimmerD", 273); ("kMutagene", 1858); ("bvenn", 260); ("Etschbeijer", 0);
        ("bellacapilla", 0); ("Joott", 754); ("Freymaurer", 710); ("SchuckL", 0);
        ("omaus", 609); ("ZimmerA", 352); ("LibraChris", 121); ("CMR248", 122);
        ("JessicaFaryadMarani", 0); ("zieglerSe", 18); ("Falkenei", 7);
        ("vLeidel", 0)|]
        |> Array.filter (fun (person,conts) -> conts > 0)
        |> Array.sortByDescending snd

    let colors = [|
        Color.Red
        Color.Gold1
        Color.Lime
        Color.Yellow
        Color.Blue
        Color.Fuchsia
        Color.Silver
        Color.Teal
        Color.Olive
        Color.Maroon
        Color.White
        Color.LightSteelBlue1
        Color.LightPink1
        Color.Green
        Color.Aqua
    |]

    let rnd = Random()

    // initialize bar chart with style
    let barChart = BarChart()
    barChart.Width <- 100
    barChart.Label <- "[underline]No. of GitHub contributions (in 2021)[/]"
    barChart.CenterLabel() |> ignore

    // add a bar with a new color (and make sure the color is unique)
    let rec addWithColor i usedColors =
        let color = colors |> Array.shuffleFisherYates rnd |> Array.head
        let cond1 = i < noOfContributionsIn2021.Length
        let cond2 = List.contains color usedColors
        if cond1 && not cond2 then
            barChart.AddItem(
                noOfContributionsIn2021[i] |> fst, 
                noOfContributionsIn2021[i] |> snd |> float, 
                color
            )
            |> ignore
            addWithColor (i + 1) (color :: usedColors)
        elif List.contains color usedColors then
            addWithColor i usedColors

    addWithColor 0 []

    AnsiConsole.Write(barChart)

#r "nuget: System.Drawing.Common, 6.0.0"

[<EntryPoint>]
let main _ =

    let bm = new System.Drawing.Bitmap(@"C:\testFolder\testDir\sp.png")

    let xMax = bm.Width - 1
    let yMax = bm.Height - 1

    // initialize a canvas with width and height
    let cnvs = Canvas(xMax + 1,yMax + 1)

    for y = 0 to yMax do
        for x = 0 to xMax do
            let px = bm.GetPixel(x,y)
            let col = Color(px.R, px.G, px.B)
            // set pixel after pixel for our picture
            cnvs.SetPixel(x,y,col)
            |> ignore

    AnsiConsole.Write(cnvs)
    Console.WriteLine()

[<EntryPoint>]
let main _ =
    
    // initialize a status report
    AnsiConsole.Status().Start(
        // first message
        "Initiating looong list...", 
        fun stCtxt -> 
            // do our stuff
            List.init 100000000 id |> ignore
            // update message after task is done
            stCtxt.Status <- "Done."
            Thread.Sleep(1000)
    )

open ConsoleToolMenu
open ConsoleToolMenu.Functions

// initialize the options you want to have
let options = [|
    // each option consists of a name and an action that gets triggered when the option is chosen
    Option.create "Option 1" (fun _ -> printfn "Option 1 was chosen")
    Option.create "Option 2" (fun _ -> printfn "Option 2 was chosen")
    // options can serve as folders, inhabiting other options
    Option.createFolder 
        "Option 3" 
        (fun _ -> printfn "Option 3 was chosen")
        (Array.map2 
            Option.create 
            [|"SubOption1"; "SubOption2"|] 
            [|(fun _ -> printfn "SubOption 1 was chosen"); fun _ -> printfn "SubOption 2 was chosen"|]
        )
    Option.createFolder 
        "Option 4" 
        (fun _ -> ()) 
        [|Option.createFolder 
            "SubOption 1b" (fun () -> ()) [|
                Option.create "SubSubOption 1" (fun _ -> printfn "SubSubOption 1 chosen")
            |]
        |]
|]

// choose the look of your cursor
let cursor = SelectionPointer.create '>'

// add messages for start and end
let startMsg = "Hello there"
let endMsg = "Goodbye there"
// start the menu. Use Up and Down arrow keys, and Enter and Escape to navigate
start cursor startMsg endMsg options

#r "nuget: NLog, 4.7.13"

open System.IO
open NLog
open NLog.Config
open NLog.Targets
open NLog.Conditions

// we start with initializing the base config object which can be modified
let config = new LoggingConfiguration()

// we initialize the first console target
let consoleTarget1 = new ColoredConsoleTarget("console")
// and set its layout to a new one we created. The string is parsed internally similar to how interpolated strings work
let layoutConsole1 = new Layouts.SimpleLayout(@"${message} ${exception}")
consoleTarget1.Layout <- layoutConsole1

// a second target that differs from the first one
let consoleTarget2 = new ColoredConsoleTarget("console")
let layoutConsole2 = new Layouts.SimpleLayout(@"${level:uppercase=true} ${message} ${exception}")
consoleTarget2.Layout <- layoutConsole2

// a file target, for writing into a text file
let fileTarget = new FileTarget("file")
let folderPath = Path.Combine("C:", "testFolder", "minimumConsoleAppNet6")
// we set filename and layout for the file target
let fileName = new Layouts.SimpleLayout(Path.Combine (folderPath, @"minimumConsoleAppNet6.log"))
let layoutFile = new Layouts.SimpleLayout("${longdate} ${level:uppercase=true} ${message} ${exception}")
fileTarget.FileName <- fileName
fileTarget.Layout <- layoutFile

// the targets are added to the config object
config.AddTarget(consoleTarget1)
config.AddTarget(consoleTarget2)
config.AddTarget(fileTarget)

// we define rules for colors that shall differ from the default color theme (which is black background, grey font)
let warnColorRule = new ConsoleRowHighlightingRule()
warnColorRule.Condition <- ConditionParser.ParseExpression("level == LogLevel.Warn")
warnColorRule.ForegroundColor <- ConsoleOutputColor.Yellow
let errorColorRule = new ConsoleRowHighlightingRule()
errorColorRule.Condition <- ConditionParser.ParseExpression("level == LogLevel.Error")
errorColorRule.ForegroundColor <- ConsoleOutputColor.Red
let fatalColorRule = new ConsoleRowHighlightingRule()
fatalColorRule.Condition <- ConditionParser.ParseExpression("level == LogLevel.Fatal")
fatalColorRule.ForegroundColor <- ConsoleOutputColor.Red
fatalColorRule.BackgroundColor <- ConsoleOutputColor.DarkYellow

// now we add the newly defined rules to the console target
consoleTarget2.RowHighlightingRules.Add(warnColorRule)
consoleTarget2.RowHighlightingRules.Add(errorColorRule)
consoleTarget2.RowHighlightingRules.Add(fatalColorRule)

// we declare which message of a log level goes to which target
config.AddRuleForOneLevel(LogLevel.Info, consoleTarget1)
config.AddRuleForOneLevel(LogLevel.Info, fileTarget)
config.AddRuleForOneLevel(LogLevel.Trace, fileTarget) // here, we only write Trace and Debug log level into the file but don't show them in the console
config.AddRuleForOneLevel(LogLevel.Debug, fileTarget)
config.AddRuleForOneLevel(LogLevel.Warn, consoleTarget2)
config.AddRuleForOneLevel(LogLevel.Warn, fileTarget)
config.AddRuleForOneLevel(LogLevel.Error, consoleTarget2)
config.AddRuleForOneLevel(LogLevel.Error, fileTarget)
config.AddRuleForOneLevel(LogLevel.Fatal, consoleTarget2)
config.AddRuleForOneLevel(LogLevel.Fatal, fileTarget)

// set the config for the logger
LogManager.Configuration <- config

// finally, we bind a logger of the name "NLog logger" to the name log which we will use afterwards
let log = LogManager.GetLogger("NLog logger")