using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.SceneManagement;
using Com.LuisPedroFonseca.ProCamera2D;

public class VNController : MonoBehaviour {
    [SerializeField] float bgCrossfadeTime = 0.5f;

    [SerializeField] DialogueController dialogueBox;

    [SerializeField] VNSpriteController vnSpriteCenter;
    [SerializeField] MoreMountains.Feedbacks.MMF_Player vnSpritePlayer;

    [SerializeField] AudioSource voiceAudioSource;
    [SerializeField] MusicFadeController music;


    [SerializeField] Image bgBack;
    // Used for cross-fading.
    [SerializeField] Image bgFront;

    [SerializeField] bool LeaveAfterDone = false;

    [SerializeField] public List<Transform> awakenOnFinish = new List<Transform>() { };

    [SerializeField] VNObjectController vnAssets;
    [HideInInspector] bool isLeaving = false;
    [HideInInspector] public bool gameOverAfterDone = false;
    [HideInInspector] public bool runawayGameOverAfterDone = false;

    [SerializeField] ProCamera2DTransitionsFX transition;

    [SerializeField] Image managerBg;

    private void Leave() {
        if (gameOverAfterDone) {
            GameData.GLOBAL = new GameData();
            gameOverAfterDone = false;
            SceneManager.LoadScene("MainMenu");
        } else if (runawayGameOverAfterDone) {
            runawayGameOverAfterDone = false;
            gameOverAfterDone = true;
            SceneManager.LoadScene("SceneViewer");
        } else {
            SceneManager.LoadScene("Manager");
        }
    }

    public void Done() {
        if (LeaveAfterDone && !isLeaving) {
            transition.OnTransitionExitEnded = Leave;
            transition.TransitionExit();
            isLeaving = true;
        } else if (runawayGameOverAfterDone) {
            VNData.NextScene = Dialogue.GameOver;
            transition.OnTransitionExitEnded = Leave;
            transition.TransitionExit();
            isLeaving = true;
        } else if (!isLeaving) {
            // Activate any UI elements that are gated on finishing the current Dialogue.
            foreach (Transform t in awakenOnFinish) {
                t.gameObject.SetActive(true);
            }
        }
    }

    public void CloseManager() {
        isLeaving = true;
        foreach (Transform t in awakenOnFinish) {
            t.gameObject.SetActive(false);
        }
    }

    private class SetSpriteOptions {
        public Body spriteBody { get; set; } = Body.None;
        public Hair spriteHair { get; set; } = Hair.None;
        public Expression spriteExpression { get; set; } = Expression.None;
        public bool removeSprite { get; set; } = false;
        public bool showBody { get; set; } = false;
    }

    private void SetSprite(VNSpriteController spriteController, SetSpriteOptions options) {
        int spriteIndex = (int)options.spriteBody - 1;
        // Load from overrides if set.
        if (options.spriteBody != Body.None && spriteIndex < vnAssets.sprites.Count) {
            spriteController.body.gameObject.SetActive(true);
            spriteController.body.sprite = vnAssets.sprites[spriteIndex];
            spriteController.hairBack.gameObject.SetActive(true);
            spriteController.hairBack.sprite = vnAssets.spriteHairBacks[(int)options.spriteHair - 1];
            spriteController.hair.gameObject.SetActive(true);
            spriteController.hair.sprite = vnAssets.spriteHairs[(int)options.spriteHair - 1];
        } else if (options.showBody)
        {
            Debug.Log(GameData.GLOBAL.bodyChoice);
            Debug.Log(GameData.GLOBAL.hairChoice);
            // Load from GameData if no override is set.
            spriteController.body.gameObject.SetActive(true);
            spriteController.body.sprite = vnAssets.sprites[(int)GameData.GLOBAL.bodyChoice - 1];
            spriteController.hairBack.gameObject.SetActive(true);
            spriteController.hairBack.sprite = vnAssets.spriteHairBacks[(int)GameData.GLOBAL.hairChoice - 1];
            spriteController.hair.gameObject.SetActive(true);
            spriteController.hair.sprite = vnAssets.spriteHairs[(int)GameData.GLOBAL.hairChoice - 1];
        }

        int spriteExpressionIndex = (int)options.spriteExpression - 1;
        if (options.spriteExpression != Expression.None && spriteExpressionIndex < vnAssets.spriteExpressions.Count) {
            spriteController.expression.gameObject.SetActive(true);
            spriteController.expression.sprite = vnAssets.spriteExpressions[spriteExpressionIndex];
        }
        
        if (options.removeSprite) {
            spriteController.body.gameObject.SetActive(false);
            spriteController.hairBack.gameObject.SetActive(false);
            spriteController.hair.gameObject.SetActive(false);
            spriteController.expression.gameObject.SetActive(false);
        }
    }

    public void Interact(DialogueInteraction interaction) {
        // Cancel any pending crossfades.
        if (bgFront != null) {
            bgFront.CrossFadeAlpha(1.0f, 0.0f, false);
        }

        // If there's a new background, fade into it.
        if (bgFront != null && bgBack != null && interaction.backgroundIndex > -1) {
            if (bgBack.sprite != null) {
                bgBack.sprite = bgFront.sprite;
                if (interaction.backgroundIndex < vnAssets.backgrounds.Count) {
                    if (bgCrossfadeTime > 0) {
                        bgFront.sprite = vnAssets.backgrounds[interaction.backgroundIndex];
                        bgFront.GetComponent<CanvasRenderer>().SetAlpha(0);
                        bgFront.CrossFadeAlpha(1.0f, bgCrossfadeTime, false);
                        Debug.Log(bgFront.color.ToString());
                        Debug.Log(bgFront.sprite.ToString());
                    } else {
                        bgFront.sprite = vnAssets.backgrounds[interaction.backgroundIndex];
                        bgFront.GetComponent<CanvasRenderer>().SetAlpha(255);
                    }
                } else {
                    Debug.LogError("Background index out of range for interaction!");
                }
            } else {
                Debug.Log(vnAssets.backgrounds.Count);
                bgFront.sprite = vnAssets.backgrounds[interaction.backgroundIndex];
                bgBack.sprite = bgFront.sprite;
                bgFront.CrossFadeAlpha(1.0f, 0.0f, false);
            }
        }

        // If there's an audio clip, play it.
        if (voiceAudioSource != null && interaction.audioClipIndex > -1) {
            if (interaction.audioClipIndex < vnAssets.voiceBank.Count) {
                voiceAudioSource.Stop();
                voiceAudioSource.PlayOneShot(vnAssets.voiceBank[interaction.audioClipIndex]);
            } else {
                Debug.LogError("AudioClip index out of range for interaction!");
            }
        }

        // If a sprite is defined, set it.
        SetSprite(vnSpriteCenter, new SetSpriteOptions() {
            spriteBody =        interaction.bodyOverride,
            spriteHair =        interaction.hairOverride,
            spriteExpression =  interaction.expression,
            removeSprite =      interaction.removeBody,
            showBody =          interaction.showBody,
        });

        if ((int)interaction.effect > 0) {
            vnSpritePlayer.FeedbacksList[(int)interaction.effect - 1].Play(Vector3.one);
        }

        // TODO: If there's a music clip, stop the currently running clip and play it.
        if (interaction.fadeMusicOut) {
            music.FadeOut(1f);
        } else if (interaction.musicClipIndex > -1) {
            if (interaction.musicClipIndex < vnAssets.musicBank.Count) {
                music.audioSource.clip = vnAssets.musicBank[interaction.musicClipIndex];
                music.audioSource.Play();
                music.FadeIn(1f);
            } else {
                Debug.LogError("AudioClip index out of range for music!");
            }
        }
    }

    // Called by DialogueControler to enforce loading before the first Interact.
    public void SetUp(Dialogue scene, bool isManagerScene = true, bool useTimeBasedBg = true) {
        voiceAudioSource = GameObject.FindWithTag("Voice").GetComponent<AudioSource>();
        music = GameObject.FindWithTag("Music").GetComponent<MusicFadeController>();
        if (isManagerScene)
        {
            // Do nothing - the manager VN inherits its own VNAssets object.
            if (useTimeBasedBg) {
                switch (GameData.GLOBAL.time) {
                    case 1: // Morning
                    case 3: // Evening
                        managerBg.sprite = vnAssets.backgrounds[0];
                        break;
                    case 2: // Day
                        managerBg.sprite = vnAssets.backgrounds[1];
                        break;
                    case 4: // Night
                        managerBg.sprite = vnAssets.backgrounds[2];
                        break;
                    default:
                        managerBg.sprite = vnAssets.backgrounds[0];
                        break;
                }
            }
        } else
        {
            // Load the respective asset pack from Resources/VNAssetPacks.
            vnAssets = Instantiate((GameObject)Resources.Load(VNData.GetDialogueAssetPackFor(scene), typeof(GameObject))).GetComponent<VNObjectController>();
        }

        if (LeaveAfterDone) {
            transition.TransitionEnter();
        }
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}