HauntedBloodlines/Assets/Scripts/Managers/Game/MainHouseP1Manager.cs

using UnityEngine;
using System;
using UnityEngine.Events;
using System.Collections;


public class MainHouseP1Manager : MonoBehaviour
{
    public enum MainHousePart1State
    {
        BeforeDiscoveringPortraitPuzzle,
        AfterDiscoveringPortraitPuzzle,
        BeforeObtainingKeyFromStatue,
        AfterObtainingKeyFromStatue,
        AfterStatuesChaseSequence,
        AfterUsedKeyForNorthHallway,
        AfterPlayerObtainsPocketWatch,
        AfterDinnerCutscene,
        BeforeTriggeredLibraryBooksPuzzle,
        //BeforeTriggeredLibraryMedallionsPuzzle,
        AfterTriggeredLibraryMedallionsPuzzle,
        AfterLibraryMedallionsPuzzleSolution,
        AfterPadlockPortraitPuzzleSolution,
        AfterObtainsKeyFromPadlockPortraitPuzzle,
        AfterUsedKeyForBabyRoom
    }

    [SerializeField] private Transform playerStartPosition;
    [SerializeField] private GameObject puzzleGameObject;
    [SerializeField] private GameObject puzzleSolvedEffects;

    [SerializeField] SaveableObjectsOnSceneManager saveableObjectsOnSceneManager;

    [SerializeField] MainHouseP1EventsData mainHouseP1EventsData;
    [SerializeField] MainHouseP1StatesData mainHouseP1StatesData;
    [SerializeField] MainHouseP1Triggers mainHouseP1Triggers;
    [SerializeField] MainHouseP1Objects mainHouseP1Objects;

    public bool isLoadingMainHouseP1Related;
    public MainHousePart1State mainHousePart1State = MainHousePart1State.BeforeDiscoveringPortraitPuzzle;

    private void Awake()
    {
        GameManager.GetInstance().mainHouseP1Manager = this;
        if (LoadManager.GetInstance().LoadingGame)
        {
            isLoadingMainHouseP1Related = true;
        }
    }

    public void Activate()
    {
        Debug.Log("Main House Part 1 Manager Activated: Initializing events.");
        TryLoadSavedState();
        UpdateStoryline();
    }

    public void Deactivate()
    {
        Debug.Log("Main House Part 1 Manager Deactivated.");

        StopAllCoroutines();
        CleanupPlayerSettings();
        SaveStorylineState();
        NotifyCompletion();
    }

    public void LoadMainHouseP1Related() 
    {
        foreach (var saveableObject in saveableObjectsOnSceneManager.SaveableObjects)
        {
            if (saveableObject.IsSetActiveTrueAfterLoad == true)
            {
                saveableObject.gameObject.SetActive(true);
            }
            else
            {
                saveableObject.gameObject.SetActive(false);
            }
        }

        //foreach (var saveableDoor in saveableObjectsOnSceneManager.SaveableDoors)
        //{
        //    if (saveableDoor.IsLockedAfterLoad == true)
        //    {
        //        saveableDoor.doorBehaviour.DoorRequiresKey = true;
        //        print("SAVEABLE DOOR REQUIRES KEY BRUH");
        //    }
        //    else
        //    {
        //        saveableDoor.doorBehaviour.DoorRequiresKey = false;
        //        print("SAVEABLE DOOR DOESNT REQUIRE KEY BRUH");
        //    }
        //}
        print("Successfully loaded main house p1 related");
    }

    public void UpdateStoryline()
    {
        switch (mainHousePart1State)
        {
            case MainHousePart1State.BeforeDiscoveringPortraitPuzzle:
                HandleBeforePuzzlePhase();
                break;

            case MainHousePart1State.AfterDiscoveringPortraitPuzzle:
                //HandlePuzzlePhase();
                mainHouseP1EventsData.afterCleanedPortraitPuzzleDust.Invoke();

                mainHouseP1StatesData.BeforeObtainingKeyFromStatueTrigger.SetActive(true);
                if (isLoadingMainHouseP1Related)
                {
                    //mainHouseP1StatesData.BeforeObtainingKeyFromStatueTrigger.SetActive(true);
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.BeforeObtainingKeyFromStatue:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.AfterObtainingKeyFromStatue:
                if (isLoadingMainHouseP1Related)
                {
                    mainHouseP1Triggers.ActivateStatuesAITrigger.SetActive(true);
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.AfterStatuesChaseSequence:
                if (isLoadingMainHouseP1Related)
                {

                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.AfterUsedKeyForNorthHallway:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                mainHouseP1EventsData.BeforePlayerObtainsPocketWatchEvent.Invoke();

                SaveStorylineState();
                break;
            case MainHousePart1State.AfterPlayerObtainsPocketWatch:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                mainHouseP1EventsData.AfterPlayerObtainsPocketWatchEvent.Invoke();

                SaveStorylineState();
                break;
            case MainHousePart1State.AfterDinnerCutscene:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                mainHouseP1StatesData.BeforeTriggeredLibraryPuzzleTrigger.SetActive(true);
                SaveStorylineState();
                break;
            case MainHousePart1State.BeforeTriggeredLibraryBooksPuzzle:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                mainHouseP1EventsData.LibraryPuzzleTimeEventsEvent.Invoke();
                SaveStorylineState();
                break;
            //case MainHousePart1State.BeforeTriggeredLibraryMedallionsPuzzle:
            //    if (isLoadingMainHouseP1Related)
            //    {
            //        isLoadingMainHouseP1Related = false;
            //    }
            //    SaveStorylineState();
            //    break;
            case MainHousePart1State.AfterTriggeredLibraryMedallionsPuzzle:
                if (isLoadingMainHouseP1Related)
                {
                    mainHouseP1EventsData.LibraryPuzzleStandColumnsEventAfterBooksPuzzle.Invoke();
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.AfterLibraryMedallionsPuzzleSolution:
                if (isLoadingMainHouseP1Related)
                {
                    mainHouseP1EventsData.AfterLibraryMedallionsPuzzleSolutionEvent.Invoke();
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.AfterPadlockPortraitPuzzleSolution:
                if (isLoadingMainHouseP1Related)
                {
                    mainHouseP1EventsData.AfterPadlockPortraitPuzzleSolutionEvent.Invoke();
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            case MainHousePart1State.AfterObtainsKeyFromPadlockPortraitPuzzle:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
            default:
                Debug.LogWarning($"Unhandled storyline state: {mainHousePart1State}");
                break;
            case MainHousePart1State.AfterUsedKeyForBabyRoom:
                if (isLoadingMainHouseP1Related)
                {
                    isLoadingMainHouseP1Related = false;
                }
                SaveStorylineState();
                break;
        }
        LoadMainHouseP1Related();
    }

    public void UpdateToNextStorylineState()
    {
        MainHousePart1State[] allStates = (MainHousePart1State[])Enum.GetValues(typeof(MainHousePart1State));
        int currentIndex = Array.IndexOf(allStates, mainHousePart1State);

        if (currentIndex < allStates.Length - 1)
        {
            mainHousePart1State = allStates[currentIndex + 1];
            UpdateStoryline();
        }
        else
        {
            Debug.Log("Main House Part 1 storyline is complete.");
            NotifyCompletion();
        }
    }

    private void HandleBeforePuzzlePhase()
    {
        Debug.Log("Setting up Before Discovering the Puzzle phase...");
        mainHouseP1EventsData.beforeDiscoveringPortraitPuzzle.Invoke();
        if (isLoadingMainHouseP1Related)
        {
            // Handles initialization after loading the game.
            //SetupPlayer(playerStartPosition, enablePlayerController: true);
            mainHouseP1StatesData.PrologueOnStorySectionComplete_PrologueCompleted.SetActive(false);
            isLoadingMainHouseP1Related = false;
        }
        else 
        {
            mainHouseP1Triggers.MainDoorCloseAndBrokenTrigger.SetActive(true);
        }

     
        SaveStorylineState();
    }

    private void HandlePuzzlePhase()
    {
        Debug.Log("Setting up Puzzle phase...");

        puzzleGameObject.SetActive(true);

        if (isLoadingMainHouseP1Related)
        {
            // Re-enable puzzle components if needed
            isLoadingMainHouseP1Related = false;
        }

        SaveStorylineState();
    }

    private void HandleAfterPuzzlePhase()
    {
        Debug.Log("Setting up After Puzzle phase...");

        puzzleGameObject.SetActive(false);
        if (puzzleSolvedEffects != null)
        {
            puzzleSolvedEffects.SetActive(true);
        }

        // Trigger post-puzzle events
        TriggerPostPuzzleEvents();
        SaveStorylineState();
        NotifyCompletion();
    }

    private void SaveStorylineState()
    {
        GameProgressManager.GetInstance().currentStorylineState = mainHousePart1State.ToString();
    }

    private void TryLoadSavedState()
    {
        if (Enum.TryParse(GameProgressManager.GetInstance().currentStorylineState, out MainHousePart1State parsedState))
        {
            mainHousePart1State = parsedState;
            Debug.Log($"Loaded saved state for Main House Part 1: {mainHousePart1State}");
            UpdateStoryline();
        }
        else
        {
            Debug.LogWarning("Invalid saved state for Main House Part 1. Defaulting to BeforeDiscoveringThePuzzle.");
            mainHousePart1State = MainHousePart1State.BeforeDiscoveringPortraitPuzzle;
        }
    }

    private void SetupPlayer(Transform newPosition, bool enablePlayerController)
    {
        var playerManager = PlayerManager.GetInstance();
        if (playerManager == null)
        {
            Debug.LogError("PlayerManager instance is missing!");
            return;
        }

        playerManager.DisablePlayerMovement();
        playerManager.playerGameObj.transform.position = newPosition.position;
        playerManager.playerGameObj.transform.rotation = newPosition.rotation;

        var gameProgressManager = GameProgressManager.GetInstance();
        gameProgressManager.playerControllerShouldBeEnabledOnGameLoad = enablePlayerController;
    }

    private void CleanupPlayerSettings()
    {
        var playerManager = PlayerManager.GetInstance();
        if (playerManager != null)
        {
            playerManager.DisablePlayerMovement();
        }

        // Add additional cleanup logic here if needed
    }

    private void TriggerPostPuzzleEvents()
    {
        Debug.Log("Triggering post-puzzle events...");
        // Implement logic for events triggered after the puzzle is solved.
        // For example:
        // UnlockNextArea();
        // ShowCompletionCutscene();
    }

    private void NotifyCompletion()
    {
        GameManager.GetInstance().OnStorySectionComplete(GameManager.StoryState.MainHousePart1);
    }

    public void ActivatePlayersSanity() 
    {
        PlayerManager.GetInstance().playerSanity.enabled = true;
        GameProgressManager.GetInstance().playerSanityShouldBeEnabledOnGameLoad = true;
    }
}
[Serializable]
public class MainHouseP1EventsData
{
    public UnityEvent beforeDiscoveringPortraitPuzzle;
    public UnityEvent afterCleanedPortraitPuzzleDust;
    public UnityEvent BeforePlayerObtainsPocketWatchEvent;
    public UnityEvent AfterPlayerObtainsPocketWatchEvent;
    public UnityEvent LibraryPuzzleTimeEventsEvent;
    public UnityEvent LibraryPuzzleStandColumnsEventAfterBooksPuzzle;
    public UnityEvent AfterLibraryMedallionsPuzzleSolutionEvent;
    public UnityEvent AfterPadlockPortraitPuzzleSolutionEvent;
}
[Serializable]
public class MainHouseP1StatesData
{
    public GameObject PrologueOnStorySectionComplete_PrologueCompleted;
    public GameObject BeforeObtainingKeyFromStatueTrigger;
    public GameObject BeforeTriggeredLibraryPuzzleTrigger;
}
[Serializable]
public class MainHouseP1Triggers
{
    public GameObject MainDoorCloseAndBrokenTrigger;
    public GameObject ActivateStatuesAITrigger;
}
[Serializable]
public class MainHouseP1Objects
{
    public GameObject FamilyPortraitBeforeSave;
    public GameObject FamilyPortraitAfterSave;
}