using System;

using System.Collections.Generic;
using System.Threading.Tasks;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using System.Net;
using System.Net.Sockets;
public class DBmanager : MonoBehaviour
{
    static RankLevel[] rankLevels;
    static RankLevel[] RankLevels {get{if(rankLevels==null){return Resources.Load<RankLevels>("ScriptableObjects/RankLevels").levels;}else{return rankLevels;}}}
    public static string phpRoot = "vmi1005083.contaboserver.net/upf/";

    public static string username = null;
    public static int userid=0;

    private static float level = 0;
    private static int xp = 0;
    private static int coins = 0;
    private static int gems = 0;
    private static int metal = 0;
    private static int tweps = 0;
    private static int trophies = 0;
    private static int mostTime=0;
    private static int doubleKills,tripleKills,quadKills,pentaKills = 0;
    private static DateTime lastCollectedDailyChest;

    private static List<InventoryEntry> inventory;
    private static List<int> expPassCollected = new List<int>();
    private static List<PurchasedSkin> skinsPurchased = new List<PurchasedSkin>(){defaultSkin};
    static PurchasedSkin defaultSkin => new PurchasedSkin(){name="Default"};
    public static Dictionary<string, BuildingState> buildingStates = new Dictionary<string, BuildingState>();
    public static UnityEvent OnStateChanged = new UnityEvent();

    public static int Xp => xp;
    public static int Coins => coins;
    public static int Gems => gems;
    public static int Metal => metal;
    public static int Tweps => tweps;
    public static int Trophies => trophies;
    public static RankLevel CurrentRank {
        get{
        RankLevel level = RankLevels[0];
        foreach(RankLevel lvl in RankLevels){
            if(Trophies > lvl.minimumTrophies){
                level = lvl;
            }else{
                break;
            }
        }

        return level;
    }}
    public static int MostTime=> mostTime;
    public static int DoubleKills => doubleKills;
    public static int TripleKills => tripleKills;
    public static int QuadKills => quadKills;
    public static int PentaKills => pentaKills;
    public static DateTime LastCollectedDailyChest => lastCollectedDailyChest;
    public static float Level => level;
    public static int LevelInt => Mathf.CeilToInt(level);
    public static List<int> ExpPassCollected => expPassCollected;
    public static List<InventoryEntry> Inventory => inventory;
    public static List<PurchasedSkin> SkinsPurchased => skinsPurchased;
    public static List<PurchasedSkin> Blueprints {get{
        List<PurchasedSkin> m_blueprints = new List<PurchasedSkin>();
        foreach(PurchasedSkin skin in SkinsPurchased){
            if(!skin.built){m_blueprints.Add(skin);}
        }
        return m_blueprints;
    }}



    public static bool LoggedIn { get { return username != null; } }
    public static bool isGuest { get {
            if(username.Contains("#")){
                string lastPart = username.Substring(username.LastIndexOf("#")+1);
                // Debug.Log(lastPart);
                return (lastPart == userid.ToString());
            }else{
                return false;
            }
        } }

    public static int Login(string jsonData){
        try{
            UserData userData = JsonUtility.FromJson<UserData>(jsonData);
            username = userData.username;
            userid = userData.id;

            DBmanager.SetLastCollectedDailyChest(userData.last_collected_daily_chest ,true);
            DBmanager.SetPentaKills(userData.penta_kills,true);
            DBmanager.SetQuadKills(userData.quad_kills,true);
            DBmanager.SetTripleKills(userData.triple_kills,true);            
            DBmanager.SetDoubleKills(userData.double_kills,true);
            DBmanager.SetMostTime(userData.most_time,true);

            DBmanager.SetPurchasedSkins(userData.skins_purchased);
            DBmanager.GetInventoryFromServer(userData.inventory);

            DBmanager.SetExpPassCollected(userData.exp_pass);
            DBmanager.SetXp(userData.xp,true);
            DBmanager.GetBuildingStates(userData.buildings);
            DBmanager.SetTrophies(userData.trophies,true);
            DBmanager.SetMetal(userData.metal,true);
            DBmanager.SetGems(userData.gems,true);
            DBmanager.SetCoins(userData.coins,true);
            DBmanager.SetTweps(userData.tweps,true);
            return 0;
        }catch (Exception e){
            Debug.LogError("Couldn't parse data into json");
            Debug.LogError(e.Message);
            Debug.LogWarning(jsonData);
            return 1;
        }
    }

    public static async Task<string> LinkAccount(string newUsername, string newPassword){
        WWWForm form = new WWWForm();
        form.AddField("id", userid);

        form.AddField("username", newUsername);
        form.AddField("password", newPassword);
        
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "link_account.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            
            return www.downloadHandler.text;            
        }
        
    }
    public static void LogOut()
    {
        username = null;
    }

    public static RankLevel GetRankForTrophies(int trophies){
        RankLevel rank = RankLevels[0];
        foreach(RankLevel level in RankLevels){
            if(trophies < level.minimumTrophies){
                break;
            }else{
                rank = level;
            }
        }

        return rank;
    }
    private static int timeDifference;
    public static Int32 unixTimestamp {get{return (int)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalSeconds;}}
    public static Int32 unixTimestampCached {get{return unixTimestamp + timeDifference;}}
    public static async Task<DateTime> GetNetworkTime()
    {
        int unixTime = 0;
        using (UnityWebRequest www = UnityWebRequest.Get(phpRoot + "get_time.php"))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }
            try
            {
                unixTime = int.Parse(www.downloadHandler.text);
            }
            catch
            {
                Debug.Log("Invalid response from server : " + www.downloadHandler.text);
            }
        }

        if (unixTime > 0)
        {
            timeDifference = unixTime - unixTimestamp;
            return DateTimeOffset.FromUnixTimeSeconds(unixTime).UtcDateTime;
        }

        //default Windows time server
        const string ntpServer = "time.windows.com";

        // NTP message size - 16 bytes of the digest (RFC 2030)
        var ntpData = new byte[48];

        //Setting the Leap Indicator, Version Number and Mode values
        ntpData[0] = 0x1B; //LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode)

        var addresses = Dns.GetHostEntry(ntpServer).AddressList;

        //The UDP port number assigned to NTP is 123
        var ipEndPoint = new IPEndPoint(addresses[0], 123);
        //NTP uses UDP

        using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
        {
            socket.Connect(ipEndPoint);

            //Stops code hang if NTP is blocked
            socket.ReceiveTimeout = 3000;

            socket.Send(ntpData);
            socket.Receive(ntpData);
            socket.Close();
        }

        //Offset to get to the "Transmit Timestamp" field (time at which the reply
        //departed the server for the client, in 64-bit timestamp format."
        const byte serverReplyTime = 40;

        //Get the seconds part
        ulong intPart = BitConverter.ToUInt32(ntpData, serverReplyTime);

        //Get the seconds fraction
        ulong fractPart = BitConverter.ToUInt32(ntpData, serverReplyTime + 4);

        //Convert From big-endian to little-endian
        intPart = SwapEndianness(intPart);
        fractPart = SwapEndianness(fractPart);

        var milliseconds = (intPart * 1000) + ((fractPart * 1000) / 0x100000000L);

        //**UTC** time
        var networkDateTime = (new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc)).AddMilliseconds((long)milliseconds);

        return networkDateTime.ToLocalTime();
    }


    static uint SwapEndianness(ulong x)
    {
        return (uint)(((x & 0x000000ff) << 24) +
        ((x & 0x0000ff00) << 8) +
        ((x & 0x00ff0000) >> 8) +
        ((x & 0xff000000) >> 24));
    }

    public async static Task SetXp(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("xp", newValue);
        if (justOffline) { xp = newValue; }
        else
        {
            using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_xp.php", form))
            {
                var operation = www.SendWebRequest();
                while (!operation.isDone)
                {
                    await Task.Yield();
                }

                if (www.downloadHandler.text == "0")
                {
                    xp = newValue;
                    // Debug
                }
                else
                {
                    Debug.Log("Response : " + www.downloadHandler.text);
                    Debug.LogWarning("Failed to set xp to " + newValue);
                }
            }
        }

        //        for(int i =0; i < xp / 100; i++){
        //            i
        //        }

        // level = (Mathf.Sqrt((float)Mathf.Clamp(xp, 100, float.PositiveInfinity) / 100f));
        // if (level == LevelInt)
        // {
        //     level -= 0.1f;
        // }
        level = GetLevelFromXP(xp);
        Debug.Log("Level : " + (float)xp / 100f + " : " + level + " : " + LevelInt);
        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    static int levelDivider = 170;
    public static float GetLevelFromXP(int _xp){
        float _level =(Mathf.Sqrt((float)Mathf.Clamp(_xp, levelDivider, float.PositiveInfinity) / (float)levelDivider));
        if(_level == Mathf.CeilToInt(_level)){
            _level -= 0.1f;
        }

        // return Mathf.CeilToInt(_level);
        return _level;
    }

    public static int XpForNextLevel(){
        int nextLevel = Mathf.CeilToInt(level);
        return (nextLevel*nextLevel) * levelDivider;
    }

    public async static Task SetCoins(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("coins", newValue);
        int oldValue = coins;
        coins = Mathf.Clamp(newValue,0,int.MaxValue);
        if (justOffline) { return; }
        AudioManager.instnace.CollectGold(newValue - oldValue);

        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_coins.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                coins = newValue;
            }
            else
            {
                coins = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set coins to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetGems(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("gems", newValue);
        int oldVal = Gems;
        gems = newValue;
        if (justOffline) {return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_gems.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                gems = newValue;
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set gems to " + newValue);
                gems = oldVal;
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetTweps(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("tweps", newValue);
        int oldVal = Tweps;
        tweps = newValue;
        if (justOffline) {return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_tweps.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                tweps = newValue;
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set tweps to " + newValue);
                tweps = oldVal;
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetMetal(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("metal", newValue);
        int oldVal = metal;
        metal = newValue;
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_metal.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                metal = newValue;
                Debug.Log("Metal updated on "+ username);
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set metal to " + newValue);
                metal = oldVal;
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetTrophies(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("trophies", newValue);
        if (justOffline) { trophies = newValue; return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_trophies.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                trophies = newValue;
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set trophies to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetMostTime(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("mostTime", newValue);
        int oldValue = mostTime;
        mostTime = newValue;
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_mostTime.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                
            }
            else
            {
                mostTime = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set most time to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetDoubleKills(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("value", newValue);
        int oldValue = doubleKills;
        doubleKills = newValue;
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_double_kills.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                
            }
            else
            {
                doubleKills = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set double kills to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetTripleKills(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("value", newValue);
        int oldValue = tripleKills;
        tripleKills = newValue;
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_triple_kills.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                
            }
            else
            {
                tripleKills = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set triple kills to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetQuadKills(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("value", newValue);
        int oldValue = quadKills;
        quadKills = newValue;
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_quad_kills.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                
            }
            else
            {
                quadKills = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set quad kills to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetPentaKills(int newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("value", newValue);
        int oldValue = pentaKills;
        pentaKills = newValue;
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_penta_kills.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                
            }
            else
            {
                pentaKills = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set penta kills to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void SetLastCollectedDailyChest(string newValue, bool justOffline = false)
    {
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("value", newValue);
        DateTime oldValue = lastCollectedDailyChest;
        lastCollectedDailyChest = DateTime.Parse(newValue);
        Debug.Log(newValue + ":"+lastCollectedDailyChest);
        if (justOffline) {  return; }
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_daily_chest_collected.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                
            }
            else
            {
                lastCollectedDailyChest = oldValue;
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set lastCollectedDailyChest to " + newValue);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }
    

    public static void SetExpPassCollected(string rawData, bool justOffline = false)
    {
        try
        {
            string[] data = rawData.Split(',');
            expPassCollected = new List<int>();
            foreach (string item in data)
            {
                try
                {
                    int itemVal = int.Parse(item);
                    expPassCollected.Add(itemVal);
                }
                catch
                {

                }
            }

            GameManager.Refresh();
            OnStateChanged.Invoke();
        }
        catch
        {

        }
    }

    public static void SetPurchasedSkins(string data){
        skinsPurchased= new List<PurchasedSkin>(){defaultSkin};
        // string[] skins = data.Split(',');
        // foreach(string skin in skins){
        //     skinsPurchased.Add(skin, 0);
        // }
        try{
            skinsPurchased = JsonConvert.DeserializeObject<List<PurchasedSkin>>(data);
        }catch{
            Debug.LogError("Error parsing skins purchased, resetting");
            skinsPurchased = new List<PurchasedSkin>(){defaultSkin};
        }
        if(skinsPurchased == null){skinsPurchased = new List<PurchasedSkin>(){defaultSkin};}
    }
    public static int GetSkinIdByName(string name){
        int value = -1;
        for(int i = 0; i < skinsPurchased.Count; i++){
            if(skinsPurchased[i].name == name){
                value = i;
                break;
            }
        }

        return value;
    }

    public static PurchasedSkin GetSkinByName(string name){
        PurchasedSkin value = null;
        for(int i = 0; i < skinsPurchased.Count; i++){
            if(skinsPurchased[i].name == name){
                value = skinsPurchased[i];
                break;
            }
        }
        // if(value ==null){
        //     Debug.LogError("No data found for " + name);
        // }
        return value;
    }

    public static void UpgradeRocketSpeed(string rocketName, RocketLevel nextLevel){
        if(coins < nextLevel.goldCost || metal < nextLevel.metalCost){
            return;
        }

        SetCoins(coins-nextLevel.goldCost);
        SetMetal(metal - nextLevel.metalCost);

        skinsPurchased[GetSkinIdByName(rocketName)].speedLevel = nextLevel.Level;
        
        UpdatePurchasedSkins();
    }


    public static void UpgradeRocketBoost(string rocketName, RocketLevel nextLevel){
        if(coins < nextLevel.goldCost || metal < nextLevel.metalCost){
            return;
        }

        SetCoins(coins-nextLevel.goldCost);
        SetMetal(metal - nextLevel.metalCost);

        skinsPurchased[GetSkinIdByName(rocketName)].boostLevel++;
        
        UpdatePurchasedSkins();
    }

    public static void UpgradeRocketEnergy(string rocketName, RocketLevel nextLevel){
        if(coins < nextLevel.goldCost || metal < nextLevel.metalCost){
            return;
        }

        SetCoins(coins-nextLevel.goldCost);
        SetMetal(metal - nextLevel.metalCost);

        skinsPurchased[GetSkinIdByName(rocketName)].energyLevel++;
        
        UpdatePurchasedSkins();
    }


    public static void PurchaseSkin(SkinShopItemData data){
        if(metal < data.price_metal || coins < data.price_gold){
            return;
        }
        SetMetal(metal-data.price_metal);
        SetCoins(coins - data.price_gold);
        AddSkin(data);
        AudioManager.instnace.ChestOpen();
    }

    public static void AddSkin(SkinShopItemData data){        
        skinsPurchased.Add(new PurchasedSkin(){name= data.name});
        UpdatePurchasedSkins();
    }
    public static void AddSkinBlueprint(SkinShopItemData data){        
        skinsPurchased.Add(new PurchasedSkin(){name= data.name,built=false});
        UpdatePurchasedSkins();
    }

    public static void BuildBlueprint(string name){
        for(int i=0; i < skinsPurchased.Count; i++){
            if(skinsPurchased[i].name == name){
                skinsPurchased[i].built= true;
                UpdatePurchasedSkins();
                break;
            }
        }
    }

    public async static void UpdatePurchasedSkins(){
        string output = JsonConvert.SerializeObject(skinsPurchased);

        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("skins", output);
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_skins_purchased.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                Debug.Log("Success updating PurchasedSkins " + output);
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set PurchasedSkins to " + output);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public async static void AddCollectedExpPass(int newPassLevel)
    {
        expPassCollected.Add(newPassLevel);
        string output = "";
        for (int i = 0; i < expPassCollected.Count; i++)
        {
            output += expPassCollected[i].ToString();
            if (i < expPassCollected.Count - 1)
            {
                output += ",";
            }
        }

        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("expPass", output);
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_expPassCollected.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                Debug.Log("Success updating ExpPassCollected");
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set exp_pass_collected to " + output);
            }
        }

        GameManager.Refresh();
        OnStateChanged.Invoke();
    }

    public static bool GetBuildingStates(string rawData)
    {
        bool success = false;
        //try{
        Debug.Log("Updating buildings");
        // List<BuildingState> m_buildingStates = JsonConvert.DeserializeObject<List<BuildingState>>(rawData);
        // Debug.Log("Updating buildings data, isNull: " + (m_buildingStates == null).ToString());
        // if (m_buildingStates == null)
        // {
        //     m_buildingStates = new List<BuildingState>();
        // }

        // buildingStates = new Dictionary<string, BuildingState>();
        // foreach(BuildingState building in m_buildingStates){
        //     buildingStates.Add(building.id, building);
        // }
        buildingStates = JsonConvert.DeserializeObject<Dictionary<string, BuildingState>>(rawData);
        Debug.Log("Updating buildings data, isNull: " + (buildingStates == null).ToString());
        if (buildingStates == null)
        {
            buildingStates = new Dictionary<string, BuildingState>();
        }

        success = true;
        //        }catch(Exception e){
        //            Debug.LogError(e.Message+'\n' + e.StackTrace);
        //
        //            Debug.LogError("Error updating buildings from server, Response:" + rawData);
        //            success=false;
        //        }

        OnStateChanged.Invoke();
        return success;
    }

   

    public async static Task AddBuilding(BuildingData buildingData)
    {
        if(buildingStates.ContainsKey(buildingData.buildingName)){
            Debug.Log("Building " + buildingData.buildingName + " Already exists"); 
            return;
        };

        Debug.Log("adding new building " + buildingData.buildingName);
        buildingStates.Add(buildingData.buildingName,new BuildingState(buildingData.buildingName, 0, Vector3.zero, await GetNetworkTime()));
        Debug.Log("Added new building " + buildingData.buildingName);
        await UpdateBuildingsToServer();
        OnStateChanged.Invoke();
        SetXp(xp + buildingData.levels[0].xpGain);
    }

    public async static Task UpgradeBuilding(string id, int newLevel)
    {
        buildingStates[id].level = newLevel;
        Debug.Log("Upgrading " + id + " to " + newLevel);
        await UpdateBuildingsToServer();

        OnStateChanged.Invoke();
    }

    public async static Task CollectBuilding(string id)
    {   
        buildingStates[id].lastCollectedTimestamp = DateTimeOffset.FromUnixTimeSeconds(unixTimestampCached).UtcDateTime;;
        buildingStates[id].lastCollectedTimestamp = await GetNetworkTime();

        BuildingManager.instance.UpdateBuildings();

        await UpdateBuildingsToServer();

        OnStateChanged.Invoke();
    }

    // public async static Task RelocateBuilding(string id, Vector3 newPosition)
    // {
    //     for (int i = 0; i < buildingStates.Count; i++)
    //     {
    //         if (buildingStates[i].id == id)
    //         {
    //             buildingStates[i].position = newPosition;
    //             Debug.Log("Relocating " + id + " to " + newPosition);
    //             // break;
    //         }
    //     }
    //     Debug.Log("Going to update to server" + JsonConvert.SerializeObject(buildingStates));
    //     await UpdateBuildingsToServer();

    //     OnStateChanged.Invoke();
    // }


    public async static Task UpdateBuildingsToServer()
    {
        string buildingsJson = JsonConvert.SerializeObject(buildingStates);
        Debug.Log(buildingsJson);

        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("buildings", buildingsJson);

        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_buildings.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {

            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set buildings to " + buildingsJson);
            }
        }
    }

    public static bool GetInventoryFromServer(string rawJson)
    {
        // try{
            inventory = JsonConvert.DeserializeObject<List<InventoryEntry>>(rawJson);
        // }catch{
        //     inventory = null;
            
        // }

        if(inventory==null){
            Debug.Log("Failed to set inventory, server said : " + rawJson);
            inventory= new List<InventoryEntry>();
        }

        return true;
    }

    public async static void AddInventoryItem(InventoryItem item)
    {
        bool exists = false;
        if(inventory==null){inventory = new List<InventoryEntry>();}
        
        foreach(InventoryEntry entry in inventory){
            if(entry.Item == item.itemName){
                entry.Count++;
                exists=true;
                break;
            }
        }
        if(!exists){
            inventory.Add(new InventoryEntry(item.itemName,1));
        }

        await UpdateInventoryToServer();
        OnStateChanged.Invoke();
    }

    public async static void RemoveInventoryItem(string item)
    {
        List<InventoryEntry> temp_inventory = inventory;
        inventory = new List<InventoryEntry>();
        foreach(InventoryEntry entry in temp_inventory){
            if(entry.Item == item){continue;}
            inventory.Add(entry);
        }

        if(inventory.Count == temp_inventory.Count){Debug.LogError("No item was removed from inventory");}

        await UpdateInventoryToServer();
        OnStateChanged.Invoke();
    }


    public async static Task UpdateInventoryToServer()
    {
        string inventoryJson = JsonConvert.SerializeObject(inventory);
        Debug.Log(inventoryJson);

        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("inventory", inventoryJson);

        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "set_inventory.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {

            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to set inventory to " + inventoryJson);
            }
        }
    }



    public async static Task SellItem(string item, int coins_amount, int gems_amount, int metals_amount, int oxygen_amount){
        
        //Insert new trade entry to server
        WWWForm form = new WWWForm();
        form.AddField("name", username);
        form.AddField("item", item);
        form.AddField("coins", coins_amount);
        form.AddField("gems", gems_amount);
        form.AddField("metals", metals_amount);
        form.AddField("oxygen", oxygen_amount);



        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "add_trade.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            if (www.downloadHandler.text == "0")
            {
                RemoveInventoryItem(item);
            }
            else
            {
                Debug.Log("Response : " + www.downloadHandler.text);
                Debug.LogWarning("Failed to add trade entry");
            }
        }

        OnStateChanged.Invoke();
    }


    public async static Task<List<LeaderboardUserData>> GetLeaderboard()
    {

        WWWForm form = new WWWForm();
        List<LeaderboardUserData> leaderboard = new List<LeaderboardUserData>();
        using (UnityWebRequest www = UnityWebRequest.Post(phpRoot + "get_leaderboard.php", form))
        {
            var operation = www.SendWebRequest();
            while (!operation.isDone)
            {
                await Task.Yield();
            }

            

            try{
                string[] split = {"<td>"};
                string[] players = www.downloadHandler.text.Split(split, StringSplitOptions.RemoveEmptyEntries);

                foreach(string player in players){
                    leaderboard.Add(JsonConvert.DeserializeObject<LeaderboardUserData>(player));
                }
            }catch{
                Debug.Log("Failed fetching Leaderboard");
                Debug.Log("Response : " + www.downloadHandler.text);
            }
        }

        return leaderboard;
    }

}

public class UserData{
    public int id;
    public string username;
    public int coins;
    public int gems;
    public int tweps;
    public int metal;
    public int xp;
    public int trophies;
    public string buildings;
    public string exp_pass;
    public string inventory;
    public string skins_purchased;
    public int most_time;
    public int double_kills;
    public int triple_kills;
    public int quad_kills;
    public int penta_kills;

    public string last_collected_daily_chest;    
}

public class LeaderboardUserData{
    public string username;
    public int trophies;
    public int position;
}

[Serializable]
public class PurchasedSkin{
    public string name;
    public int speedLevel;
    public int boostLevel;
    public int energyLevel;
    public bool built=true;
}