using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using Snxxz.UI;
using System.Text.RegularExpressions;

[XLua.LuaCallCSharp]
public class InGameDownLoad : SingletonMonobehaviour<InGameDownLoad>
{
    public const int BYTE_PER_KILOBYTE = 1024;
    public const int BYTE_PER_MILLIONBYTE = 1048576;

    List<RemoteFile> workingQueue = new List<RemoteFile>();
    List<AssetVersion> tasks = new List<AssetVersion>();
    Dictionary<int, List<AssetVersion>> mapTasks = new Dictionary<int, List<AssetVersion>>();

    public bool inGameDownLoadAllow = false;

    public float progress {
        get {
            return Mathf.Clamp01((float)showDownLoadedSize / showTotalSize);
        }
    }

    public bool isDone { get { return state == State.Completed; } }
    public long showDownLoadedSize { get { return downLoadedSizeRecord + RemoteFile.TotalDownloadedSize - backGroundDownLoadSizeRecord; } }
    public long showTotalSize { get { return totalSize - backGroundDownLoadSizeRecord; } }
    public int showTotalCount { get { return totalCount - downLoadedCountRecord; } }
    public int showOkCount { get { return okCount - downLoadedCountRecord; } }

    long totalSize = 0;
    int totalCount = 0;

    int m_OkCount = 0;
    int okCount {
        get { return m_OkCount; }
        set {
            m_OkCount = value;
        }
    }

    long backGroundDownLoadSizeRecord = 0;//后台偷偷已经下载到资源量
    long downLoadedSizeRecord = 0;//记录上次暂停时记录的下载量
    int downLoadedCountRecord = 0;//已经下载完成的资源包数量

    public event Action<State> downLoadStateChangeEvent;
    public event Action<Dominant> dominantDownLoadEvent;

    Action onDownLoadOk;

    Dominant m_DominantState = Dominant.None;
    public Dominant dominantState {
        get { return m_DominantState; }
        private set {
            if (m_DominantState != value)
            {
                m_DominantState = value;
                if (dominantDownLoadEvent != null)
                {
                    dominantDownLoadEvent(m_DominantState);
                }
            }
        }
    }

    State m_State = State.None;
    public State state {
        get { return m_State; }
        set {
            if (m_State != value)
            {
                m_State = value;

                if (downLoadStateChangeEvent != null)
                {
                    downLoadStateChangeEvent(m_State);
                }
            }
        }
    }

    int maxWorkingTask = 2;

    TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }

    public List<Reward> rewards = new List<Reward>();
    public bool hasReward { get; private set; }
    public string completeDownLoadAccount {
        get { return LocalSave.GetString("InGameDownLoadCompleteAccount"); }
        set { LocalSave.SetString("InGameDownLoadCompleteAccount", value); }
    }

    public Redpoint downLoadRedpoint = new Redpoint(116);

    public void AssignTasks(List<AssetVersion> _tasks, Action _onDownLoadOk)
    {
        inGameDownLoadAllow = false;
        tasks = _tasks;
        tasks.Sort(AssetDownLoadPriorCompare);
        onDownLoadOk = _onDownLoadOk;

        totalCount = tasks.Count;
        okCount = 0;
        totalSize = 0;

        for (int i = 0; i < tasks.Count; i++)
        {
            var task = tasks[i];
            totalSize += task.size;
        }

        for (var i = 0; i < tasks.Count; i++)
        {
            var assetVersion = tasks[i];
            var mapId = PriorBundleConfig.GetAssetBelongToMap(assetVersion.GetAssetCategory(), assetVersion.fileName);
            if (mapId != 0)
            {
                if (!mapTasks.ContainsKey(mapId))
                {
                    mapTasks[mapId] = new List<AssetVersion>();
                }
                mapTasks[mapId].Add(assetVersion);
            }
        }

        state = State.None;

        TaskModel.Event_MainlineTask -= OnMainTaskChange;
        TaskModel.Event_MainlineTask += OnMainTaskChange;

        PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerLevelChange;
        PlayerDatas.Instance.playerDataRefreshEvent += OnPlayerLevelChange;
    }

    public void ParseRewardConfig()
    {
        var rewardString = FuncConfigConfig.Get("DownReward").Numerical1;
        var matches = Regex.Matches(rewardString, "(\\d+,\\d+,\\d+)");
        for (int i = 0; i < matches.Count; i++)
        {
            rewards.Add(new Reward(matches[i].Value));
        }
    }

    public void UpdateRewardInfo(HA319_tagMCPackDownloadRecord _package)
    {
        hasReward = _package.Record == 1;

        if (AssetVersionUtility.unPriorAssetDownLoadDone)
        {
            state = !hasReward && completeDownLoadAccount == PlayerDatas.Instance.baseData.AccID ? State.Award : State.Completed;
        }

        downLoadRedpoint.state = state == State.Award ? RedPointState.Simple : RedPointState.None;
    }

    public void RequestDownLoadReward(bool _manual)
    {
        var send = new CA504_tagCMPlayerGetReward();
        send.RewardType = 15;
        send.DataEx = (byte)(_manual ? 0 : 1);
        GameNetSystem.Instance.SendInfo(send);
    }

    public float GetMapAssetDownLoadProgress(int mapId)
    {
        if (!mapTasks.ContainsKey(mapId))
        {
            return 1f;
        }

        var tasks = mapTasks[mapId];
        var total = tasks.Count;
        if (total == 0)
        {
            return 1f;
        }

        var completeCount = 0;
        foreach (var task in tasks)
        {
            if (task.localValid)
            {
                completeCount++;
            }
        }

        return completeCount / (float)total;
    }

    int mapId = 0;
    Action mapAssetDownLoadOk;
    public void RegisterMapAssetDownLoadOk(int mapId, Action callBack)
    {
        var progress = GetMapAssetDownLoadProgress(mapId);
        if (progress < 0.999f)
        {
            this.mapId = mapId;
            mapAssetDownLoadOk = callBack;
        }
    }

    public void UnRegisterMapAssetDownLoadOk()
    {
        this.mapId = 0;
        mapAssetDownLoadOk = null;
    }

    public void TryDownLoad(Dominant _dominant)
    {
        if (!inGameDownLoadAllow)
        {
            return;
        }

        if (tasks == null || tasks.Count == 0 || isDone)
        {
            return;
        }

        if (_dominant < dominantState)
        {
            return;
        }

        switch (_dominant)
        {
            case Dominant.None:
                if (InGameDownTestUtility.enable)
                {
                    if (InGameDownTestUtility.isWifi)
                    {
                        StartDownLoad();
                    }
                }
                else
                {
                    if (Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork)
                    {
                        StartDownLoad();
                    }
                }
                break;
            case Dominant.Half:
                if (dominantState == Dominant.None)
                {
                    backGroundDownLoadSizeRecord = RemoteFile.TotalDownloadedSize;
                    downLoadedCountRecord = okCount;
                }
                StartDownLoad();
                dominantState = Dominant.Half;
                break;
            case Dominant.Whole:
                if (dominantState == Dominant.None)
                {
                    backGroundDownLoadSizeRecord = RemoteFile.TotalDownloadedSize;
                    downLoadedCountRecord = okCount;
                    Pause();
                    state = State.Prepared;
                }
                else if (dominantState == Dominant.Half)
                {
                    Pause();
                    state = State.Prepared;
                }

                dominantState = Dominant.Whole;
                WindowCenter.Instance.Open<InGameDownLoadWin>();
                break;
        }

    }

    public void StartDownLoad()
    {
        if (state == State.None || state == State.Prepared || state == State.Pause)
        {
            state = State.DownLoad;
            RemoteFile.maxDownLoadTask = 2;
            RemoteFile.MaxConnectLimit = 12;
            StartCoroutine("Co_StartDownLoad");
        }
    }

    public void Pause()
    {
        if (state == State.DownLoad)
        {
            StopCoroutine("Co_StartDownLoad");
            foreach (var remoteFile in workingQueue)
            {
                remoteFile.Stop();
            }
            workingQueue.Clear();
            RemoteFile.maxDownLoadTask = 0;
            RemoteFile.MaxConnectLimit = 0;
            state = State.Pause;
        }
    }

    IEnumerator Co_StartDownLoad()
    {
        downLoadedSizeRecord += RemoteFile.TotalDownloadedSize;
        RemoteFile.Prepare();
        workingQueue.Clear();
        okCount = 0;

        var downLoadTasksQueues = new Queue<AssetVersion>();

        for (int i = 0; i < tasks.Count; i++)
        {
            var assetVersion = tasks[i];
            if (!assetVersion.localValid)
            {
                downLoadTasksQueues.Enqueue(assetVersion);
            }
            else
            {
                okCount++;
            }
        }

        while (okCount < totalCount)
        {
            while (workingQueue.Count < maxWorkingTask && downLoadTasksQueues.Count > 0)
            {
                var assetVersion = downLoadTasksQueues.Dequeue();
                var remoteURL = StringUtility.Contact(VersionUtility.Instance.versionInfo.GetResourcesURL(VersionConfig.Get().branch), "/", assetVersion.relativePath);
                var localURL = StringUtility.Contact(ResourcesPath.Instance.ExternalStorePath, assetVersion.relativePath);

                var remoteFile = new RemoteFile();
                workingQueue.Add(remoteFile);
                remoteFile.Init(remoteURL, localURL, assetVersion, true);
                remoteFile.Begin(OnFileDownLoadCompleted);
            }
            yield return null;
        }

        TaskModel.Event_MainlineTask -= OnMainTaskChange;
        PlayerDatas.Instance.playerDataRefreshEvent -= OnPlayerLevelChange;

        WindowCenter.Instance.Close<InGameDownLoadWin>();

        if (!hasReward)
        {
            if (dominantState == Dominant.None)
            {
                RequestDownLoadReward(false);
                state = State.Completed;
            }
            else
            {
                completeDownLoadAccount = PlayerDatas.Instance.baseData.AccID;
                state = State.Award;
            }
        }
        else
        {
            state = State.Completed;
        }

        downLoadRedpoint.state = state == State.Award ? RedPointState.Simple : RedPointState.None;

        if (onDownLoadOk != null)
        {
            onDownLoadOk();
            onDownLoadOk = null;
        }
    }

    private void OnFileDownLoadCompleted(bool _ok, AssetVersion _assetVersion)
    {
        foreach (var remote in workingQueue)
        {
            if (remote.assetVersion == _assetVersion)
            {
                workingQueue.Remove(remote);
                break;
            }
        }

        if (_ok)
        {
            okCount++;
            _assetVersion.localValid = true;
        }
        else
        {
            var remoteURL = StringUtility.Contact(VersionUtility.Instance.versionInfo.GetResourcesURL(VersionConfig.Get().branch), "/", _assetVersion.relativePath);
            var localURL = StringUtility.Contact(ResourcesPath.Instance.ExternalStorePath, _assetVersion.relativePath);

            var remoteFile = new RemoteFile();
            workingQueue.Add(remoteFile);
            remoteFile.Init(remoteURL, localURL, _assetVersion, true);
            remoteFile.Begin(OnFileDownLoadCompleted);
        }
    }

    Clock netSwitchClock;
    NetworkReachability m_NetworkReachability = NetworkReachability.NotReachable;
    NetworkReachability networkReachability {
        get { return m_NetworkReachability; }
        set {
            if (m_NetworkReachability != value)
            {
                m_NetworkReachability = value;

                if (dominantState != Dominant.Whole)
                {
                    switch (m_NetworkReachability)
                    {
                        case NetworkReachability.ReachableViaCarrierDataNetwork:
                            Pause();
                            var endTime = DateTime.Now + new TimeSpan(TimeSpan.TicksPerSecond * 3);
                            if (netSwitchClock != null)
                            {
                                Clock.Stop(netSwitchClock);
                            }

                            netSwitchClock = Clock.AlarmAt(endTime, () =>
                             {
                                 if (CheckDominantDownLoad())
                                 {
                                     TryDownLoad(Dominant.Whole);
                                 }
                             });
                            break;
                        case NetworkReachability.ReachableViaLocalAreaNetwork:
                            TryDownLoad(Dominant.None);
                            break;
                        default:
                            break;
                    }
                }
            }
        }
    }

    bool m_SimulateWifi = true;
    public bool simulateWifi {
        get { return m_SimulateWifi; }
        set {
            if (m_SimulateWifi != value)
            {
                m_SimulateWifi = value;

                if (dominantState != Dominant.Whole)
                {
                    if (m_SimulateWifi)
                    {
                        TryDownLoad(Dominant.None);
                    }
                    else
                    {
                        Pause();
                        var endTime = DateTime.Now + new TimeSpan(TimeSpan.TicksPerSecond * 10);
                        Clock.AlarmAt(endTime, () =>
                        {
                            if (CheckDominantDownLoad())
                            {
                                TryDownLoad(Dominant.Whole);
                            }
                        });
                    }
                }
            }

        }
    }

    float netCheckTimer = 0f;

    private void LateUpdate()
    {
        if (state == State.None || state == State.Award || state == State.Completed)
        {
            return;
        }

        netCheckTimer += Time.deltaTime;

        if (InGameDownTestUtility.enable)
        {
            simulateWifi = InGameDownTestUtility.isWifi;
        }
        else
        {
            if (netCheckTimer > 3f)
            {
                netCheckTimer = 0f;
                networkReachability = Application.internetReachability;
            }
        }

        if (mapId != 0)
        {
            var progress = GetMapAssetDownLoadProgress(mapId);
            if (progress > 0.9999f)
            {
                if (mapAssetDownLoadOk != null)
                {
                    mapAssetDownLoadOk();
                    mapAssetDownLoadOk = null;
                    mapId = 0;
                }
            }
        }

    }

    public bool CheckDominantDownLoad()
    {
        if (tasks == null || tasks.Count == 0 || isDone || dominantState == Dominant.Whole || NewBieCenter.Instance.inGuiding)
        {
            return false;
        }

        if (GeneralDefine.inGameDownLoadLevelCheckPoints == null || GeneralDefine.inGameDownLoadLevelCheckPoints.Count == 0)
        {
            return false;
        }

        if (PlayerDatas.Instance.baseData.LV < GeneralDefine.inGameDownLoadLevelCheckPoints[0])
        {
            return false;
        }

        if (PlayerDatas.Instance.baseData.LV < GeneralDefine.inGameDownLoadHighLevel)
        {
            if (InGameDownTestUtility.enable)
            {
                if (InGameDownTestUtility.isWifi)
                {
                    return false;
                }
            }
            else
            {
                if (Application.internetReachability != NetworkReachability.ReachableViaCarrierDataNetwork)
                {
                    return false;
                }
            }
        }

        if (!WindowCenter.Instance.IsOpen("MainInterfaceWin"))
        {
            return false;
        }

        if (WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
        {
            return false;
        }

        return true;
    }

    public bool IsHighLevelPlayer()
    {
        if (GeneralDefine.inGameDownLoadLevelCheckPoints == null
            || GeneralDefine.inGameDownLoadLevelCheckPoints.Count == 0)
        {
            return false;
        }

        var level = PlayerDatas.Instance.baseData.LV;
        return level > GeneralDefine.inGameDownLoadHighLevel;
    }

    private void OnPlayerLevelChange(PlayerDataType refreshType)
    {
        switch (refreshType)
        {
            case PlayerDataType.LV:
                var level = PlayerDatas.Instance.baseData.LV;
                var count = GeneralDefine.inGameDownLoadLevelCheckPoints.Count;
                var lastLevelCheckPoint = GeneralDefine.inGameDownLoadLevelCheckPoints[count - 1];
                if (GeneralDefine.inGameDownLoadLevelCheckPoints.Contains(level) || IsHighLevelPlayer())
                {
                    if (CheckDominantDownLoad())
                    {
                        TryDownLoad(Dominant.Whole);
                    }
                }
                break;
        }
    }

    private void OnMainTaskChange(int _taskId, int _state)
    {
        var mainTaskId = taskModel.currentMission;
        if (GeneralDefine.inGameDownLoadTaskCheckPoints.Contains(mainTaskId)
            && taskModel.currentMissionState == 1)
        {
            if (CheckDominantDownLoad())
            {
                TryDownLoad(Dominant.Whole);
            }
        }
    }

    private int AssetDownLoadPriorCompare(AssetVersion lhs, AssetVersion rhs)
    {
        var categoryA = lhs.GetAssetCategory();
        var categoryB = rhs.GetAssetCategory();
        var priorA = PriorBundleConfig.GetAssetPrior(categoryA, lhs.fileName);
        var priorB = PriorBundleConfig.GetAssetPrior(categoryB, rhs.fileName);

        if (priorA != priorB)
        {
            return priorA < priorB ? -1 : 1;
        }
        else
        {
            var isManifestA = lhs.extersion == ".manifest";
            var isManifestB = rhs.extersion == ".manifest";

            if (!isManifestA && isManifestB)
            {
                return -1;
            }
            else if (isManifestA && !isManifestB)
            {
                return 1;
            }
            else
            {
                return 0;
            }
        }
    }

    private int GetMaxTask()
    {
        switch (Application.platform)
        {
            case RuntimePlatform.Android:
                if (DeviceUtility.cpu >= 4 && DeviceUtility.memory > 3.2f * 1024)
                {
                    return 2;
                }
                else
                {
                    return 1;
                }
            case RuntimePlatform.IPhonePlayer:
                if (DeviceUtility.cpu > 1 && DeviceUtility.memory > 1.5f * 1024)
                {
                    return 2;
                }
                else
                {
                    return 1;
                }
            case RuntimePlatform.WindowsEditor:
                return 2;
            default:
                return 1;
        }

    }

    private void Awake()
    {
        maxWorkingTask = GetMaxTask();
    }

    public struct Reward
    {
        public int id;
        public int count;
        public bool bind;

        public Reward(string _input)
        {
            var matches = Regex.Matches(_input, "\\d+");

            if (matches.Count > 0)
            {
                int.TryParse(matches[0].Value, out id);
            }
            else
            {
                id = 0;
            }

            if (matches.Count > 1)
            {
                int.TryParse(matches[1].Value, out count);
            }
            else
            {
                count = 0;
            }

            if (matches.Count > 2)
            {
                var temp = 0;
                int.TryParse(matches[2].Value, out temp);
                bind = temp == 1;
            }
            else
            {
                bind = false;
            }
        }

    }

    public enum State
    {
        None,
        Prepared,
        DownLoad,
        Pause,
        Award,
        Completed,
    }

    public enum Dominant
    {
        None = 0,
        Half = 1,
        Whole = 2,
    }

}