using System;
using System.IO;
using System.Security.Cryptography;
using System.Threading;
using SteamKit2.Discovery;

using SteamKit2;
using SteamKit2.Internal; // brings in our protobuf client messages
using SteamKit2.GC; // brings in the GC related classes
using SteamKit2.GC.Artifact.Internal;
using System.Text;

namespace ShowPlayers
{
    class Program
    {
    static SteamClient steamClient;
    static CallbackManager manager;

    static SteamUser steamUser;

    static bool isRunning;

    static string user, pass;
    static string authCode, twoFactorAuth;
     const int APPID = 346110;
    static SteamGameCoordinator gameCoordinator;


        static void Main(string[] args)
    {

        user = "...";
        pass = "...";
        steamClient = new SteamClient();
        manager = new CallbackManager(steamClient);

        steamUser = steamClient.GetHandler<SteamUser>();
        gameCoordinator = steamClient.GetHandler<SteamGameCoordinator>();


        manager.Subscribe<SteamClient.ConnectedCallback>(OnConnected);
        manager.Subscribe<SteamClient.DisconnectedCallback>(OnDisconnected);

        manager.Subscribe<SteamUser.LoggedOnCallback>(OnLoggedOn);
        manager.Subscribe<SteamUser.LoggedOffCallback>(OnLoggedOff);
        manager.Subscribe<SteamUser.UpdateMachineAuthCallback>(OnMachineAuth);
        manager.Subscribe<SteamFriends.PersonaStateCallback>(OnPersona);
       isRunning = true;

        Console.WriteLine("Connecting to Steam...");

        steamClient.Connect();
        while (isRunning)
        {
            manager.RunWaitCallbacks(TimeSpan.FromSeconds(1));
        }
    }
        static void OnPersona(SteamFriends.PersonaStateCallback callback)
        {

            Console.WriteLine("Connected to Steam! Logging in '{0}'...", callback);

        }



        static void OnConnected(SteamClient.ConnectedCallback callback)
    {
        Console.WriteLine("Connected to Steam! Logging in '{0}'...", user);

        byte[] sentryHash = null;
        if (File.Exists("sentry.bin"))
        {
            // if we have a saved sentry file, read and sha-1 hash it
            byte[] sentryFile = File.ReadAllBytes("sentry.bin");
            sentryHash = CryptoHelper.SHAHash(sentryFile);
        }

        steamUser.LogOn(new SteamUser.LogOnDetails
        {
            Username = user,
            Password = pass,

            // in this sample, we pass in an additional authcode
            // this value will be null (which is the default) for our first logon attempt
            AuthCode = authCode,

            // if the account is using 2-factor auth, we'll provide the two factor code instead
            // this will also be null on our first logon attempt
            TwoFactorCode = twoFactorAuth,

            // our subsequent logons use the hash of the sentry file as proof of ownership of the file
            // this will also be null for our first (no authcode) and second (authcode only) logon attempts
            SentryFileHash = sentryHash,
        });

            var playGame = new ClientMsgProtobuf<CMsgClientGamesPlayed>(EMsg.ClientGamesPlayedWithDataBlob);
            playGame.Body.client_os_type = 16;

            playGame.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed
            {
                steam_id_gs = 90127163137042442,
                game_id = new GameID(APPID), // or game_id = APPID,
                game_ip_address = 621444212,
                game_port = 7781,
                game_extra_info = "",
                process_id = 18964,
                game_flags = 0,
                owner_id = 400168753,
            });

            // send it off
            // notice here we're sending this message directly using the SteamClient
         // steamClient.Send(playGame);


        }

    static void OnDisconnected(SteamClient.DisconnectedCallback callback)
    {
        // after recieving an AccountLogonDenied, we'll be disconnected from steam
        // so after we read an authcode from the user, we need to reconnect to begin the logon flow again

        Console.WriteLine("Disconnected from Steam, reconnecting in 5...");

        Thread.Sleep(TimeSpan.FromSeconds(5));

        steamClient.Connect();
    }

    static void OnLoggedOn(SteamUser.LoggedOnCallback callback)
    {
        bool isSteamGuard = callback.Result == EResult.AccountLogonDenied;
        bool is2FA = callback.Result == EResult.AccountLoginDeniedNeedTwoFactor;

        if (isSteamGuard || is2FA)
        {
            Console.WriteLine("This account is SteamGuard protected!");

            if (is2FA)
            {
                Console.Write("Please enter your 2 factor auth code from your authenticator app: ");
                twoFactorAuth = Console.ReadLine();
            }
            else
            {
                Console.Write("Please enter the auth code sent to the email at {0}: ", callback.EmailDomain);
                authCode = Console.ReadLine();
            }

            return;
        }

        if (callback.Result != EResult.OK)
        {
            Console.WriteLine("Unable to logon to Steam: {0} / {1}", callback.Result, callback.ExtendedResult);

            isRunning = false;
            return;
        }

        Console.WriteLine("Successfully logged on!");
        File.WriteAllText("cellid.txt", callback.CellID.ToString());

        }

    static void OnLoggedOff(SteamUser.LoggedOffCallback callback)
    {
        Console.WriteLine("Logged off of Steam: {0}", callback.Result);
    }

    static void OnMachineAuth(SteamUser.UpdateMachineAuthCallback callback)
    {
        Console.WriteLine("Updating sentryfile...");

        // write out our sentry file
        // ideally we'd want to write to the filename specified in the callback
        // but then this sample would require more code to find the correct sentry file to read during logon
        // for the sake of simplicity, we'll just use "sentry.bin"

        int fileSize;
        byte[] sentryHash;
        using (var fs = File.Open("sentry.bin", FileMode.OpenOrCreate, FileAccess.ReadWrite))
        {
            fs.Seek(callback.Offset, SeekOrigin.Begin);
            fs.Write(callback.Data, 0, callback.BytesToWrite);
            fileSize = (int)fs.Length;

            fs.Seek(0, SeekOrigin.Begin);
            using (var sha = SHA1.Create())
            {
                sentryHash = sha.ComputeHash(fs);
            }
        }

        // inform the steam servers that we're accepting this sentry file
        steamUser.SendMachineAuthResponse(new SteamUser.MachineAuthDetails
        {
            JobID = callback.JobID,

            FileName = callback.FileName,

            BytesWritten = callback.BytesToWrite,
            FileSize = fileSize,
            Offset = callback.Offset,

            Result = EResult.OK,
            LastError = 0,

            OneTimePassword = callback.OneTimePassword,

            SentryFileHash = sentryHash,
        });

        Console.WriteLine("Done!");
    }
}
}