open FSharp.Control
open System
open System.Threading
open TdLib

type Wtf() =
    static member ApiId = 8568794
    static member ApiHash = "er8mkeop2kpzrb3mhj50y46u64baqerg"
    static member PhoneNumber = "+7901450930" // must contain prefix
    static member ResetEvent = ManualResetEventSlim()
    static member val AuthNeeded = false with get, set
    static member val Client = TdClient() with get, set

TdLog.SetVerbosityLevel(0)
Wtf.Client <- TdClient()

Wtf.Client.UpdateReceived.Add(
    fun (update : TdApi.Update) ->
        async {
            match update with
            | :? TdApi.Update.UpdateOption as o ->
                let! _ = Wtf.Client.ExecuteAsync(TdApi.SetOption(Extra = o.Extra, Name = o.Name, Value = o.Value, DataType = o.DataType))
                         |> Async.AwaitTask
                ()
            | :? TdApi.Update.UpdateAuthorizationState as updateAuthorizationState ->
                match updateAuthorizationState.AuthorizationState with
                | :? TdApi.AuthorizationState.AuthorizationStateWaitTdlibParameters ->
                    let! _ = Wtf.Client.ExecuteAsync(TdApi.SetTdlibParameters(
                                                        Parameters = TdApi.TdlibParameters(
                                                            ApiId = Wtf.ApiId,
                                                            ApiHash = Wtf.ApiHash,
                                                            ApplicationVersion = "1.3.0",
                                                            DeviceModel = "PC",
                                                            SystemLanguageCode = "en",
                                                            SystemVersion = "Win 10.0")))
                             |> Async.AwaitTask
                    ()
                | :? TdApi.AuthorizationState.AuthorizationStateWaitEncryptionKey ->
                    let! _ = Wtf.Client.ExecuteAsync(TdApi.CheckDatabaseEncryptionKey())
                             |> Async.AwaitTask
                    ()
                | ( :? TdApi.AuthorizationState.AuthorizationStateWaitPhoneNumber
                  | :? TdApi.AuthorizationState.AuthorizationStateWaitCode ) ->
                    Wtf.AuthNeeded <- true
                    Wtf.ResetEvent.Set()
                | _ -> ()
            | :? TdApi.Update.UpdateUser -> Wtf.ResetEvent.Set()
            | _ -> () (* add a breakpoint here to see other events *)
        }
        |> Async.StartImmediate)

Wtf.ResetEvent.Wait()
if Wtf.AuthNeeded then
    async {
        let! _ = Wtf.Client.ExecuteAsync(TdApi.SetAuthenticationPhoneNumber(PhoneNumber = Wtf.PhoneNumber))
                 |> Async.AwaitTask
        Console.Write("Insert the login code: ")
        let code = Console.ReadLine()
        let! _ = Wtf.Client.ExecuteAsync(TdApi.CheckAuthenticationCode(Code = code))
                 |> Async.AwaitTask
        ()
    }
    |> Async.StartImmediate

let GetChannels(offsetOrder : int64 option, offsetId : int64 option, limit : int option) =
    asyncSeq {
        let offsetOrder_ = defaultArg offsetOrder Int64.MaxValue
        let offsetId_ = defaultArg offsetId 0L
        let limit_ = defaultArg limit 1000
        let! chats = Wtf.Client.ExecuteAsync(TdApi.GetChats(OffsetOrder=offsetOrder_, Limit=limit_, OffsetChatId=offsetId_))
                    |> Async.AwaitTask
        for chatId in chats.ChatIds do
            let! chat = Wtf.Client.ExecuteAsync(TdApi.GetChat(ChatId = chatId))
                        |> Async.AwaitTask
            match chat.Type with
            | ( :? TdApi.ChatType.ChatTypeSupergroup
              | :? TdApi.ChatType.ChatTypeBasicGroup
              | :? TdApi.ChatType.ChatTypePrivate ) -> yield chat
            | _ -> ()
    }

GetChannels(None, None, None)
|> AsyncSeq.iter (fun chat -> printfn $"{chat.Title}")
|> Async.RunSynchronously

Console.ReadLine() |> ignore