using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

public class CharacterBehaviour : MonoBehaviour
{

    [SerializeField]
    private bool standby = true;


    [Range(3, 15)]
    public float disappearTime = 5;

    public Material mat;

    public Area area;
    public Vector2 wallRoi;
    public Vector2 heightRange = new Vector2(0.0f, 0.5f);
    float origin_height = 0.0f;
    [SerializeField]
    private RectTransform fakeButton;

    public DShowClip standbyClip;
    public DShowClip triggerClip;
    [SerializeField]
    private DShowMoviePlayer[] players;
    private MeshRenderer m_meshRender;
    public Color color;
    private bool isSleep;

    public float videoStopTime = 1.5f;

    private const float checktriggerColliderTime = 0.5f;
    private float triggerColliderTimer;

    private void Awake()
    {
        m_meshRender = GetComponent<MeshRenderer>();
        mat = new Material(Shader.Find("Unlit/ColorTransparent"));
        m_meshRender.material = mat;

        origin_height = transform.position.y;

        InitialiseDSPlayer();
    }

    void InitialiseDSPlayer()
    {
#if false
        GameObject triggerObj = new GameObject("Trigger");
        triggerObj.transform.parent = this.transform;
        SetClip(triggerObj.AddComponent<DShowMoviePlayer>(), triggerClip);
        GameObject standbyObj = new GameObject("Standby");
        standbyObj.transform.parent = this.transform;
        SetClip(standbyObj.AddComponent<DShowMoviePlayer>(), standbyClip);
#else
        CreateDSPlayer(triggerClip);
        CreateDSPlayer(standbyClip);
        
#endif
        players = GetComponentsInChildren<DShowMoviePlayer>();
    }

    void CreateDSPlayer(DShowClip clip)
    {
        GameObject triggerObj = new GameObject(clip.name);
        triggerObj.transform.parent = this.transform;
        SetClip(triggerObj.AddComponent<DShowMoviePlayer>(), clip);
    }

    void SetClip(DShowMoviePlayer player, DShowClip clip)
    {
        player.VideoAsset = clip;
        player.Load();
    }

    void InitialTouchButton()
    {
        if (fakeButton != null)
            return;
        GameObject obj = new GameObject(gameObject.name);
        obj.transform.parent = GameObject.Find("Final Canvas").transform;
        fakeButton = obj.AddComponent<RectTransform>();
        fakeButton.anchorMin = new Vector2(0, 0);
        fakeButton.anchorMax = new Vector2(0, 0);
        fakeButton.pivot = new Vector2(0.5f, 0.5f);
        fakeButton.sizeDelta = new Vector2(transform.localScale.x, transform.localScale.y) * FrozenScreenToWorldSpace.Instance.finalPixelsByMeter;
        fakeButton.anchoredPosition3D = new Vector3(0, 0, 0);
        fakeButton.localScale = Vector3.one;
        fakeButton.gameObject.AddComponent<RawImage>();
        fakeButton.GetComponent<RawImage>().color = new Color(1, 1, 1, 0);
        TouchArea touch_area = fakeButton.gameObject.AddComponent<TouchArea>();
        touch_area.PointerDown.AddListener((data) => { Trigger(data); });
        touch_area.PointerDrag.AddListener((data) => { Trigger(data); });
    }

    private void Start()
    {
        //standby = true;
        //isSleep = false;
        mat.mainTextureScale = new Vector2(1, -1);
        mat.mainTextureOffset = new Vector2(0, -1);
        //StartCoroutine(PlayOnStart());
        //InitialTouchButton();
        //StartCoroutine(RandomPosNoTriggerOther());
    }

    private void OnEnable()
    {
        standby = true;
        isSleep = false;
        StartCoroutine(PlayOnStart());
        InitialTouchButton();
        StartCoroutine(RandomPosNoTriggerOther());
        color = new Color(1,1,1,0);
        StartCoroutine(Sleep());
    }

    private void OnDisable()
    {
        
    }

    IEnumerator PlayOnStart()
    {
        DShowMoviePlayer player = currentPlayer;
        player.Loop = true;
        while (!player.IsPlaying)
        {
            player.Play();
            mat.mainTexture = player.Texture;
            yield return null;
        }
    }
    
    void Update()
    {

        if (Input.GetKeyDown(KeyCode.R))
        {
            if (!isTriggerCollider)
                StartCoroutine(RandomPosNoTriggerOther());
        }

        UpdateMaterial();

        if (!isSleep)
        {
            if (!standby)
                CheckPlayFinished();
        }

        if (isTriggerCollider)
            CheckTriggerCollider();
    }

    void CheckTriggerCollider()
    {
        triggerColliderTimer -= Time.deltaTime;
        if (triggerColliderTimer <= 0)
            isTriggerCollider = false;
    }


    void UpdateMaterial()
    {
        mat.mainTexture = currentPlayer.Texture;
        mat.SetColor("_Color", color);
    }

    void CheckPlayFinished()
    {
        if (currentPlayer.IsFinished)
        {
            StartCoroutine(Sleep());
        }
    }

    void RandomAppearWall()
    {
        Vector3 newPos = Vector3.zero;
        area = (Area)Random.Range(0, 3);
        Quaternion q = new Quaternion();
        if (area == Area.LeftWall)
        {
            newPos.x = -FrozenScreenToWorldSpace.Instance.length / 2;
            q.SetLookRotation(Vector3.left);
        }
        if (area == Area.RightWall)
        {
            newPos.x = FrozenScreenToWorldSpace.Instance.length / 2;
            q.SetLookRotation(Vector3.right);
        }
        if (area == Area.TopWall)
        {
            newPos.z = FrozenScreenToWorldSpace.Instance.width / 2;
            q.SetLookRotation(Vector3.forward);
        }
        transform.rotation = q;
        transform.localPosition = newPos;
        RandomPos();
    }

    void UpdatePos()
    {
        Vector3 n_pos = transform.localPosition;
        if (area == Area.TopWall)
            n_pos.x = Mathf.Lerp(-FrozenScreenToWorldSpace.Instance.length / 2, FrozenScreenToWorldSpace.Instance.length / 2, wallRoi.x);
        else
            n_pos.z = Mathf.Lerp(-FrozenScreenToWorldSpace.Instance.width / 2, FrozenScreenToWorldSpace.Instance.width / 2, wallRoi.x);
        n_pos.y = Mathf.Lerp(0, (float)FrozenScreenToWorldSpace.Instance.height, wallRoi.y);
        transform.localPosition = n_pos;
        SetButtonPos();
    }


    void RandomPos()
    {
        Vector3 randomPos = transform.localPosition;
        float minX = transform.localScale.x / 2;

        if (randomPos.x == 0)
            wallRoi.x = Random.Range(minX, FrozenScreenToWorldSpace.Instance.length - minX) / FrozenScreenToWorldSpace.Instance.length;
        else
            wallRoi.x = Random.Range(minX, FrozenScreenToWorldSpace.Instance.width - minX) / FrozenScreenToWorldSpace.Instance.width;
        
        wallRoi.y = (origin_height + Random.Range(heightRange.x, heightRange.y)) / FrozenScreenToWorldSpace.Instance.height;
        UpdatePos();
        SetButtonPos();
    }

    void SetButtonPos()
    {
        Vector2 newScreenPos = FrozenScreenToWorldSpace.Instance.GetFinalScreenPos(area, wallRoi);
        fakeButton.anchoredPosition = newScreenPos;
    }

    private void Trigger(PointerEventData data)
    {
        if (!standby || isSleep)
            return;
        standby = false;
        currentPlayer.Play();
        mat.mainTexture = currentPlayer.Texture;
    }

    void Idle()
    {
        standby = true;
        currentPlayer.Play();
    }

    DShowMoviePlayer currentPlayer { get { return players[System.Convert.ToInt32(standby)]; } }

    IEnumerator Sleep()
    {
        standby = false;
        isSleep = true;
        yield return StartCoroutine(WaitVideoStopTimeFadeOut());
        yield return new WaitForSeconds(GetDisAppear());
        yield return StartCoroutine(RandomPosNoTriggerOther());
        yield return StartCoroutine(WaitVideoStandbyFadeIn());
        isSleep = false;
        Idle();
    }

    IEnumerator Fade(float targetA)
    {
        float value = 0;
        float origin = color.a;
        while (value < 1)
        {
            value = Mathf.Clamp(value + Time.deltaTime, 0, 1);
            color.a = Mathf.Lerp(origin, targetA, value);
            yield return null;
        }
        color.a = targetA;
    }

    IEnumerator WaitVideoStandbyFadeIn()
    {
        standby = true;
        currentPlayer.Play();
        mat.mainTexture = currentPlayer.Texture;
        yield return StartCoroutine(Fade(1));
    }

    IEnumerator WaitVideoStopTimeFadeOut()
    {
        yield return new WaitForSeconds(videoStopTime);
        yield return StartCoroutine(Fade(0));
        currentPlayer.Pause();
        currentPlayer.Frame = 0;
    }


    public bool isTriggerCollider;

    private void OnTriggerExit(Collider other)
    {
        isTriggerCollider = false;
    }

    void OnTriggerStay(Collider other)
    {
        isTriggerCollider = true;
        triggerColliderTimer = checktriggerColliderTime;
    }

    private void OnTriggerEnter(Collider other)
    {
        isTriggerCollider = true;
        triggerColliderTimer = checktriggerColliderTime;
    }


    public float GetDisAppear()
    {
        float distime = disappearTime - Random.Range(0, disappearTime / 2);
        distime = disappearTime * distime - distime * distime + 0.5f * distime;
        return distime;
    }

    IEnumerator RandomPosNoTriggerOther()
    {
        RandomAppearWall();
        yield return null;
        yield return new WaitForSeconds(0.1f);
        while (isTriggerCollider)
        {
            RandomAppearWall();
            yield return null;
        }
    }
}