using Cinemachine;
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.Collections.LowLevel.Unsafe;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.Animations;

using UnityEngine.Rendering.PostProcessing;
using UnityEngine.SceneManagement;

/* 本代码控制室内场景
 * 控制宠物在Home场景动画
 * ！！！特别注意：Dog Initializer 必须挂载在同一个组件下，并且必须在本组价下方。确保比本组件先执行
 * 主要调节参数在FixedUpdate代码段里面
 * 提示用户注册
 */

public class HomeController : MonoBehaviour
{

    public static List<DogInScene> dogsInScene = new List<DogInScene>();
    public static bool listenBreak = false;       // 当按下说话按键后，所有狗停止行动，立刻切换到监听状态。
    public static CinemachineVirtualCamera playerCam, dogCam;
    public static DateTime lastCameraChange;
    private bool isSleepChecked = false;        // 用于检测第一次睡眠检测是否执行完成
    // Start is called once before the first execution of Update after the MonoBehaviour is created
    void Start()
    {
        dogsInScene.Clear();        // dogsInScene 是静态，每次启动要清空
        lastCameraChange = DateTime.Now;
        playerCam = GameObject.Find("VCam Player").GetComponent<CinemachineVirtualCamera>();
        dogCam = GameObject.Find("VCam Dog").GetComponent<CinemachineVirtualCamera>();

        //InitialScene();
        StartCoroutine(InitialScene());
    }

    // Update is called once per frame
    void FixedUpdate()
    {
        if (SceneInitialCheck())      // 确保狗读取成功后执行代码
        {
            // 每次启动检测一次是否进入睡眠
            if (!isSleepChecked)
            {
                // 判断是否在睡觉时间
                DateTime dateTime = DateTime.Now;

                foreach (var dog in dogsInScene)
                {
                    if (dateTime.Hour >= 22 || dateTime.Hour <= 5)      // 深夜模式，狗默认在睡觉状态
                    {
                        dog.Sleep();
                    }
                    else if (dog.dogProperty.stamina <= 10) { dog.Sleep(); }        // 狗体力太低了，进入睡觉模式
                    else
                    {
                        dog.StartAnimation();
                    }
                }
                isSleepChecked = true;
            }

            #region 场景动画主循环
            // 检测狗是否被撞翻，如果是，立刻翻回来
            foreach (var dog in dogsInScene)
            {
                Quaternion curRotation = dog.gameObject.transform.rotation;
                if (curRotation.x != 0)
                {
                    curRotation.x = 0;
                }
                if (curRotation.z != 0)
                {
                    curRotation.z = 0;
                }
                dog.gameObject.transform.rotation = curRotation;
            }

            // 生成一个数据数用于随机开启动画，如果和狗的randomFactor相同就开启动画
            int randomCheck = UnityEngine.Random.Range(0, 51);

            foreach (var dog in dogsInScene)
            {
                // 如果在eat drink进程结束前不执行随机场景代码
                if (dog.eatProgress || dog.itemConsumeProgress)
                {
                    if (dog.isMovingToBowl)
                    {
                        dog.MovetoBowl();
                    }
                }
                else
                {    // 随机动作控制控制   
                     // 随机镜头切换代码
                    RandomCameraChange();

                    if (listenBreak)        // 如果用户按下说话按键，立刻切换到监听状态
                    {
                        dog.Listen();
                    }
                    else if (dog.isMoving)
                    {
                        dog.Move();
                    }

                    else if (randomCheck == dog.randomFactor && !dog.isSleeping)        // 当狗自身的随机数和系统随机数相同时候触发。约100秒触发一次。
                    {
                        TimeSpan ts = DateTime.Now - dog.animationStartTime;
                        if (ts.Seconds >= 30)        // 如果距离上一个动作超过30秒就可以开始新的动作
                        {
                            float r = UnityEngine.Random.Range(0, 1f);
                            if (r > 0.6)       // 随机选择开始动画，或者移动
                            {
                                dog.StartAnimation();
                            }
                            else        // 狗狗开始步行移动
                            {
                                dog.SetMoveSpeed(0);
                                dog.moveSpeed = 0;
                                dog.Move();
                            }
                        }
                    }
                }
            }
            #endregion
        }

    }

    private void OnDestroy()
    {
        Debug.Log("Home scene is destoried.");
    }
    //void AniOrWalk(DogInScene dog)        // 狗在普通状态下，随机或播放动画，或移动
    //{

    //}

    // 初始化场景，加载所有的狗，并配置components，添加到dogsInScene List里面去
    //void InitialScene()
    IEnumerator InitialScene()
    {
        //yield return null;     
        //yield return null;     
        yield return null;      // 跳过三帧，初始化最多三只狗
        //Debug.Log(isInitialDone);
        foreach (var dog in UserProperty.dogs)
        {
            DogInScene dogInScene = new DogInScene(dog);
            float x = UnityEngine.Random.Range(-1f, 1f);        // 随机生成位置，考虑到手机评估宽度限制宽度
            float z = UnityEngine.Random.Range(-5f, 5f);
            float y = UnityEngine.Random.Range(0, 360f);
            var initPosition = new Vector3(x, 0, z);
            StartCoroutine(DogComponentAdd(dog));       // 加载狗的其他组件
            var dogGameObject = GameObject.Find(dog.dog_name);
            if (dogGameObject == null)
            {
                Debug.Log(dog.dog_name + "is not found in Home Controller");
            }
            dogGameObject.transform.position = initPosition;
            dogGameObject.transform.rotation = Quaternion.Euler(0, y, 0);
            dogGameObject.transform.localScale = new Vector3(2, 2, 2);
            dogInScene.SetGameObject(dogGameObject);
            dogsInScene.Add(dogInScene);
        }
    }

    // 加载狗的其他组件
    IEnumerator DogComponentAdd(DogProperty dogProperty)
    {
        // 等待一帧，确保所有 Start() 方法都执行完成
        yield return null;

        // 第一帧以后开始执行
        GameObject dog = GameObject.Find(dogProperty.dog_name);

        // 加载指定的Animator controller
        Animator animator = dog.GetComponent<Animator>();
        RuntimeAnimatorController animatorController = Resources.Load<RuntimeAnimatorController>("Dog/AnimatorController/shibaInu/HomeDogAnimatorController");
        if (dogProperty.breed == "shibaInu") { animatorController = Resources.Load<RuntimeAnimatorController>("Dog/AnimatorController/shibaInu/HomeDogAnimatorController"); }

        animator.runtimeAnimatorController = animatorController;

        // 加载Rigidbody
        Rigidbody rigidbody = dog.AddComponent<Rigidbody>();
        //Rigidbody rigidbody = dog.GetComponent<Rigidbody>();
        //rigidbody.isKinematic = true;
        rigidbody.mass = 10;
        rigidbody.linearDamping = 10;
        rigidbody.angularDamping = 10;
        //rigidbody.freezeRotation = true;
        rigidbody.constraints = RigidbodyConstraints.FreezePositionY | RigidbodyConstraints.FreezeRotation;
        rigidbody.interpolation = RigidbodyInterpolation.Interpolate;
        rigidbody.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;

        // 加载box collider
        BoxCollider boxCollider = dog.AddComponent<BoxCollider>();
        boxCollider.isTrigger = false;
        boxCollider.center = new Vector3(0, 0.25f, 0);
        boxCollider.size = new Vector3(0.12f, 0.45f, 0.54f);

        //yield return null;
    }

    // 场景随机切换镜头看向不同的狗
    void RandomCameraChange()
    {
        int delay = 10;     // 延迟10秒执行一次
        TimeSpan ts = DateTime.Now - lastCameraChange;
        if (ts.TotalSeconds < delay) {return;}
        int dogCount = dogsInScene.Count;
        int r = UnityEngine.Random.Range(0, dogCount+1);
        if (r < dogCount)
        {
            dogCam.m_LookAt = dogsInScene[r].gameObject.transform;
            dogCam.Priority = 10;
            playerCam.Priority = 1;
        }
        else
        {
            dogCam.Priority = 1;
            playerCam.Priority = 10;
        }
        lastCameraChange = DateTime.Now;
    }

    // 检测场景是否初始化完成
    bool SceneInitialCheck()
    {
        bool initDone = true;
        if (dogsInScene.Count == UserProperty.dogs.Count)       // 检测是否所有狗都被加载
        {
            foreach (var dog in dogsInScene)
            {
                if(dog.gameObject.GetComponent<Animator>().runtimeAnimatorController == null)
                {
                    initDone = false;
                }
            }
        }
        else
        {
            initDone=false;
        }
        //Debug.Log("Home scene initial status:"+initDone);
        return initDone;
    }
}

// 本类用于管理场景中所有狗的状态包括动画状态，随机数分配等
public class DogInScene
{
    //通用参数段
    public DogProperty dogProperty;
    public GameObject gameObject { set; get; }
    public Animator animator;
    private Vector3 moveToLocation;
    public float moveSpeed;     // 用来控制狗的移动速度 0 0.5跑，0.75快跑，1跳

    // 喝水吃饭参数段
    public DateTime drinkStartTime, eatStartTime;      // 记录吃喝开始时间
    public bool itemConsumeProgress, eatProgress = false;     // 是否在吃和喝的进程中。如果是的话，跳过常规动画检测
    public bool isMovingToBowl;


    // 随机动作参数段
    public int randomFactor;
    public DateTime animationStartTime;     // 记录上一个动画开始时间的，每个随机动作间隔至少30秒
    private int activeIndex;      // 动物的活动指数
    public bool isMoving;       // 动物正在移动，避免其他随机动作发生
    public bool isSleeping;       // 动物正在正在睡觉，避免触发其他动画

    // 固定参数
    private float moveSpeedAdj = 0.025f;


    #region 通用函数段
    public void SetGameObject(GameObject gameObject)
    {
        this.gameObject = gameObject;
        this.animator = gameObject.GetComponent<Animator>();
        this.randomFactor = UnityEngine.Random.Range(0, 51);        // 生成一个随机整数（0 到 50 之间），用于时间校验
        Debug.Log(this.gameObject.name + "random factor is:"+randomFactor);
    }
    

    public DogInScene(DogProperty property) {
        this.dogProperty = property;
        this.activeIndex = (int)Math.Round((property.liveliness + property.intimate) * UnityEngine.Random.Range(0.3f, 0.7f));
        this.isMoving = false;
    }
    #endregion

    #region 随机动作控制函数


// 随机选择宠物动作
    public void StartAnimation()
    {
        this.animationStartTime = DateTime.Now;
        this.animator.SetInteger("activeIndex", activeIndex);
        //Debug.Log("activeIndex:" + this.activeIndex);
        float randomIndex = UnityEngine.Random.Range(0, 1f);
        this.animator.SetFloat("randomIndex", randomIndex);
        //Debug.Log("randomIndex:" + randomIndex);
    }

    public void SetMoveSpeed(float speed)
    {
        this.moveSpeed = speed;
    }

    public void Move()
    {

        // 如果距离目标小于0.5米就把速度调整为零
        if (Vector3.Distance(moveToLocation, this.gameObject.transform.position) < 0.5f)
        {
            //Debug.Log(this.gameObject.name + "current move speed:" + moveSpeed);
            this.SetMoveSpeed(0);
            //Debug.Log(this.gameObject.name + "reduce move speed:" + moveSpeed);
        }
        
        if (isMoving == false)
        {
            animationStartTime = DateTime.Now;      // 设置动画开始时间
            float x = UnityEngine.Random.Range(-5f, 5f);
            float z = UnityEngine.Random.Range(0f, 5f);
            this.moveToLocation = new Vector3(x, 0, z);
            //Debug.Log("move to location:" + x + ", " + z);
            this.isMoving = true;
            this.animator.SetTrigger("move");
            this.animator.SetBool("isMoving", true);
            this.animator.SetFloat("moveSpeed", this.moveSpeed);
        }
        this.gameObject.transform.LookAt(moveToLocation);
        this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, dogProperty.runSpeed * (1 + moveSpeed) * 0.02f * moveSpeedAdj);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应RM动画
        //this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, (100 + dogProperty.runSpeed) * (1 + moveSpeed) * 0.02f * 0.015f);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应IF动画
        //Debug.Log("current position:" + gameObject.transform.position.x + "z:" + gameObject.transform.position.z);

        // 如果狗距离到达重点就停止跑步动画
        float distance = Vector3.Distance(gameObject.transform.position, moveToLocation);
        if (distance  < 0.1)
        {
            this.animator.SetBool("isMoving", false);
            //this.moveSpeed = 0.4f;
            this.isMoving = false;
            StartAnimation();
        }
    }

    public void Sleep()
    {
        this.animator.SetTrigger("sleep");
        this.animator.SetBool("isSleeping", true);  
        this.isSleeping = true;
    }

    public void Listen()
    {
        //StopCoroutine(movingCoroutine);
        //this.animator.SetTrigger("listen");
        this.animator.SetBool("isListening", true);
        this.animator.SetBool("isMoving", false) ;
        this.animator.SetBool("isBarking", false);
        this.animator.SetBool("isSleeping", false);
        this.isSleeping= false;     // 主人呼叫可以唤醒狗
        this.gameObject.transform.LookAt(new Vector3(0, 0, -6));
        HomeController.playerCam.Priority = 10;
        HomeController.dogCam.Priority = 1;
        HomeController.lastCameraChange = DateTime.Now;
    }

    // 用来出来音频返回结果
    public void PostListen(bool result)
    {
        if (result)
        {
            // TODO 语音信息识别成功，狗狗跑过来
        }
        else
        {
            this.animator.SetBool("isListening", false);
        }
    }

    #endregion

    #region 喝水，吃食等道具消费函数
    // 开始整个使用道具的流程
    public void StartItemConsume(ItemGroup group)
    {

        GameObject bowl = GameObject.Find("Bowl_water");        // 先指定一个碗，编译通过

        this.itemConsumeProgress = true;        // 开启使用道具过程
        if (group == ItemGroup.water)
        {
            bowl = GameObject.Find("Bowl_water");       // 开启整个喝水的进程
        }
        if (group == ItemGroup.food) 
        {
            bowl = GameObject.Find("Bowl_food");        // 开启整个吃食物的进程
        }
        this.moveToLocation = bowl.transform.position;
        this.isMovingToBowl = true;
        this.animator.SetTrigger("move");       // 切换为走路动画
        this.animator.SetBool("isMoving", true);        // 保持为走路动画
        this.animator.SetFloat("moveSpeed", this.moveSpeed);
    }

    public void MovetoBowl()
    {

        // 如果距离目标小于0.5米就把速度调整为零
        if (Vector3.Distance(moveToLocation, this.gameObject.transform.position) < 0.5f)
        {
            Debug.Log(this.gameObject.name + "current move speed:" + moveSpeed);
            this.SetMoveSpeed(0);
            Debug.Log(this.gameObject.name + "reduce move speed:" + moveSpeed);
        }

        var vamUI = GameObject.Find("VoiceAndMenu");
        if (vamUI != null)
        {
            vamUI.SetActive(false);
        }
        this.gameObject.transform.LookAt(moveToLocation);
        this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, dogProperty.runSpeed * (1 + moveSpeed) * 0.02f * moveSpeedAdj);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应RM动画
        //this.gameObject.transform.position = Vector3.MoveTowards(gameObject.transform.position, moveToLocation, (100+dogProperty.runSpeed) * (1 + moveSpeed) * 0.02f * 0.015f);  // 第一个0.02对应50帧fixupdate画面，后面一个数字对应速度调整，对应IF动画
        //Debug.Log("current position:" + gameObject.transform.position.x + "z:" + gameObject.transform.position.z);

        // 如果狗距离到达重点就停止跑步动画
        float distance = Vector3.Distance(gameObject.transform.position, moveToLocation);
        if (distance < 0.1)
        {
            this.animator.SetBool("isMoving", false);
        }
    }

    public IEnumerator DrinkAnimation()

    {
        this.animator.SetBool("isMoving", false);       // 关闭移动动画
        TimeSpan ts = new TimeSpan();
        var targetBowl = GameObject.Find("Bowl_water");

        

        // 摄像头看向水盆位置
        HomeController.dogCam.m_LookAt = targetBowl.transform;
        HomeController.dogCam.Priority = 10;
        HomeController.playerCam.Priority = 1;

        while (ts.TotalSeconds < 10)
        {
            yield return new WaitForSeconds(0.25f);
            ts = DateTime.Now - this.drinkStartTime;
            //Debug.Log("结束饮水过程:" + ts.TotalSeconds);

            // 狗一致看向谁碰，确保就算被撞击后依然看向水盆
            this.gameObject.transform.LookAt(targetBowl.transform.position);
        }
        // 播放10秒后结束饮水过程
        this.animator.SetBool("isDrinking", false);

        // 摄像头恢复玩家视角
        HomeController.dogCam.Priority = 1;
        HomeController.playerCam.Priority = 10;

        //var water = GameObject.Find("Water");
        //water.SetActive(false);

        // 再等待几秒后让水盆消失
        while (ts.TotalSeconds < 18)
        {
            yield return new WaitForSeconds(0.25f);
            ts = DateTime.Now - this.drinkStartTime;
            //Debug.Log("让水盆消失:" + ts.TotalSeconds);
        }
        
        targetBowl.transform.position = new Vector3(-1, -10, -1);       // 将喝水碗回归原位
        this.itemConsumeProgress = false;      // 关闭整个喝水的进程

        QuitItemConsume();
    }

    public IEnumerator EatAnimation()
    {
        this.animator.SetBool("isMoving", false);       // 关闭移动动画
        TimeSpan ts = new TimeSpan();
        var targetBowl = GameObject.Find("Bowl_food");


        // 摄像头看向盆位置
        HomeController.dogCam.m_LookAt = targetBowl.transform;
        HomeController.dogCam.Priority = 10;
        HomeController.playerCam.Priority = 1;

        while (ts.TotalSeconds < 10)
        {
            yield return new WaitForSeconds(0.25f);
            ts = DateTime.Now - this.eatStartTime;
            //Debug.Log("结束饮水过程:" + ts.TotalSeconds);

            // 狗一致看向谁碰，确保就算被撞击后依然看向水盆
            this.gameObject.transform.LookAt(targetBowl.transform.position);
        }
        // 播放10秒后结束饮水过程
        this.animator.SetBool("isEating", false);

        // 摄像头恢复玩家视角
        HomeController.dogCam.Priority = 1;
        HomeController.playerCam.Priority = 10;

        //var water = GameObject.Find("Water");
        //water.SetActive(false);

        // 再等待几秒后让水盆消失
        while (ts.TotalSeconds < 15)
        {
            yield return new WaitForSeconds(0.25f);
            ts = DateTime.Now - this.drinkStartTime;
            //Debug.Log("让水盆消失:" + ts.TotalSeconds);
        }

        targetBowl.transform.position = new Vector3(-1, -10, -1);       // 将喝水碗回归原位
        this.itemConsumeProgress = false;      // 关闭整个喝水的进程

        QuitItemConsume();
    }

    private void QuitItemConsume()
    {
        var uiPlaceholder = GameObject.Find("UI Placeholder");
        var vamUI = uiPlaceholder.transform.Find("VoiceAndMenu").gameObject;
        vamUI.SetActive(true);
        this.moveSpeed = UnityEngine.Random.Range(0.3f,0.6f);
        Move();

        
    }

    #endregion
        
}

// 
public enum ItemGroup
{
    food,
    water
}