using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using System;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using GKC.Localization;

[System.Serializable]
public class saveGameSystem : MonoBehaviour
{
    [Header ("Main Settings")]
    [Space]

    public int sceneToLoadNewGame;
    public int saveStationId;

    public bool isPhysicalSaveStation = true;

    public bool usePlayerCameraOrientation;

    [Space]

    public bool manualSaveEnabled = true;

    [Space]

    public int defaultPlayerID = 0;

    [Space]
    [Header ("Current Scene Index Settings")]
    [Space]

    public bool setCustomCurrentSceneIndex;
    public int customCurrentSceneIndex;

    [Space]
    [Header ("Load Screen Settings")]
    [Space]

    public bool useLoadScreen;

    public int loadScreenScene = 1;

    public bool useLastSceneIndexAsLoadScreen = true;

    public string sceneToLoadAsyncPrefsName = "SceneToLoadAsync";

    public bool checkLoadingScreenSceneConfigured = true;

    public string loadingScreenSceneName = "Loading Screen Scene";

    [Space]
    [Header ("Checkpoint Settings")]
    [Space]

    public bool checkpointSlotCanBeDeletedEnabled;

    public bool deleteHiddenCheckpointSaveOnNewGameEnabled;

    public bool deleteHiddenCheckpointSaveOnContinueGameEnabled;

    public bool overwriteCheckpointSlotWhenSavingOnReturnToHome;

    [Space]
    [Header ("Save Game Icon Settings")]
    [Space]

    public bool useSavingIcon;

    public bool useCanvasGroupOnShowSavingGamePanel = true;
    public float showSavingGamePanelDuration = 3;
    public float showSavingGamePanelFadeSpeed = 5;

    public string savingGameAnimationName;
    public float animationSpeed = 0.5f;

    [Space]
    [Header ("Physical Save Station Settings")]
    [Space]

    public string animationName;

    public LayerMask savePositionLayermask;

    [Space]
    [Header ("Save Element List Settings")]
    [Space]

    public List<saveInfo> saveInfoList = new List<saveInfo> ();

    [Space]

    public bool saveInfoListToLoadOnStartOnAllScenesEnabled;

    public int saveNumberToLoadOnStartOnAllScenes = 143;

    [Space]

    public List<saveInfo> saveInfoListToLoadOnStartOnAllScenes = new List<saveInfo> ();

    [Space]
    [Header ("Other Settings")]
    [Space]

    public string chapterTextField = "Chapter";
    public string saveTextField = "Save";

    [Space]

    public Color disableButtonsColor;
    public Vector2 captureResolution;

    [Space]
    [Header ("Custom Save Element List Settings")]
    [Space]

    public List<customSaveListInfo> customSaveListInfoList = new List<customSaveListInfo> ();

    [Space]
    [Header ("Event Settings")]
    [Space]

    public bool useEventIfGameToContinueAvailable;
    public UnityEvent eventfGameToContinueAvailable;

    [Space]
    [Header ("Event Settings On Save/Load Game")]
    [Space]

    public bool useEventOnSaveGame;
    public eventParameters.eventToCallWithInteger eventOnSaveGame;

    public bool useEventOnLoadGame;
    public eventParameters.eventToCallWithInteger eventOnLoadGame;

    [Space]
    [Header ("Debug")]
    [Space]

    public bool showDebugInfo;

    public bool ignoreShowDebugInfoOnSave;
    public bool ignoreShowDebugInfoOnLoad;

    public bool usingSaveStation;
    public bool canSave;
    public bool canLoad;
    public bool canDelete;

    [Space]

    public List<buttonInfo> saveGameListElements = new List<buttonInfo> ();

    [Space]

    public saveStationInfo mainSaveStationInfo;

    [Space]
    [Header ("Components")]
    [Space]

    public Transform saveStationPosition;
    public GameObject savingIcon;

    public GameObject playerCameraGameObject;
    public GameObject playerControllerGameObject;
    public playerController mainPlayerController;
    public playerCamera mainPlayerCameraManager;

    public playerComponentsManager mainPlayerComponentsManager;

    public gameManager gameManagerComponent;

    public GameObject saveMenu;
    public Image saveButton;
    public Image loadButton;
    public Image deleteButton;
    public Scrollbar scrollBar;
    public GameObject saveGameList;
    public Camera photoCapturer;

    [Space]
    [Header ("Save Game System Info Debug")]
    [Space]

    public int slotInfoNumberDebug;
    public bool showAllGameInfoDebug;


    Animation stationAnimation;

    Button currentButton;
    Color originalColor;
    int currentButtonIndex;

    string currentSaveDataPath = "";
    string currentSaveDataName = "";

    GameObject slotPrefab;
    Animation savingGameAnimation;
    int checkpointSlotsAmount = 1;
    electronicDevice electronicDeviceManager;

    Coroutine savingGamePanelInfoCoroutine;

    bool initialized;

    bool savingGameManuallyActive;


    void Start ()
    {
        startGameSystem ();
    }

    public void startGameSystem ()
    {
        if (initialized) {
            return;
        }

        bool mainGameManagerLocated = gameManagerComponent != null;

        if (!mainGameManagerLocated) {
            gameManagerComponent = gameManager.Instance;

            mainGameManagerLocated = gameManagerComponent != null;
        }

        if (!mainGameManagerLocated) {
            gameManagerComponent = FindObjectOfType<gameManager> ();

            gameManagerComponent.getComponentInstanceOnApplicationPlaying ();
        }

        currentSaveDataPath = gameManagerComponent.getDataPath ();
        currentSaveDataName = gameManagerComponent.getDataName ();

        saveMenu.SetActive (true);

        saveGameSlot curretSaveGameSlot = saveGameList.GetComponentInChildren<saveGameSlot> ();
        slotPrefab = curretSaveGameSlot.gameObject;

        saveGameListElements.Add (curretSaveGameSlot.buttonInfo);

        int slotsAmount = gameManagerComponent.getSlotBySaveStation () - 1;

        for (int i = 0; i < slotsAmount; i++) {
            addSaveSlot (i);
        }

        //Add checkpoint slots
        for (int i = 0; i < checkpointSlotsAmount; i++) {
            addSaveSlot (saveGameListElements.Count - 1);

            buttonInfo currentSaveButtonInfo = saveGameListElements [saveGameListElements.Count - 1];

            currentSaveButtonInfo.isCheckpointSave = true;
            currentSaveButtonInfo.slotGameObject.SetActive (false);
        }

        //Add auto save slot which is hidden
        addSaveSlot (saveGameListElements.Count - 1);

        saveGameListElements [saveGameListElements.Count - 1].usedForAutoLoadSave = true;
        saveGameListElements [saveGameListElements.Count - 1].slotGameObject.SetActive (false);

        resetScroll (scrollBar);

        saveMenu.SetActive (false);

        if (isPhysicalSaveStation) {
            if (stationAnimation == null) {
                stationAnimation = GetComponent<Animation> ();
            }
        }

        if (isPhysicalSaveStation) {
            RaycastHit hit = new RaycastHit ();

            if (Physics.Raycast (saveStationPosition.position, -Vector3.up, out hit, 10, savePositionLayermask)) {
                saveStationPosition.position = hit.point + Vector3.up * 0.05f;
            }
        }

        setSaveGameTransformInfo (saveStationPosition, true);

        if (setCustomCurrentSceneIndex) {
            mainSaveStationInfo.saveStationScene = customCurrentSceneIndex;
        } else {
            mainSaveStationInfo.saveStationScene = SceneManager.GetActiveScene ().buildIndex;
        }

        originalColor = loadButton.color;

        changeButtonsColor (false, false, false, false);

        setPhotoCapturerState (false);

        if (useSavingIcon) {
            if (!useCanvasGroupOnShowSavingGamePanel) {
                savingGameAnimation = savingIcon.GetComponent<Animation> ();
            }
        }

        if (isPhysicalSaveStation) {
            electronicDeviceManager = GetComponent<electronicDevice> ();
        }

        if (useEventIfGameToContinueAvailable) {
            List<saveStationInfo> saveList = loadFile ();

            if (saveList.Count > 0) {
                eventfGameToContinueAvailable.Invoke ();
            }
        }

        initialized = true;

        //loadStates ();
    }

    public void addSaveSlot (int index)
    {
        GameObject newSlotPrefab = (GameObject)Instantiate (slotPrefab, slotPrefab.transform.position, slotPrefab.transform.rotation, slotPrefab.transform.parent);

        newSlotPrefab.transform.localScale = Vector3.one;
        newSlotPrefab.name = "Save Game Slot " + (index + 2);

        saveGameListElements.Add (newSlotPrefab.GetComponent<saveGameSlot> ().buttonInfo);
    }

    public void setSaveGameTransformInfo (Transform savePosition, bool canUsePlayerCameraOrientation)
    {

        if (savePosition == null) {
            return;
        }

        Vector3 currentPosition = savePosition.position;
        Vector3 currentEulerAngles = savePosition.eulerAngles;

        mainSaveStationInfo.saveStationPositionX = currentPosition.x;
        mainSaveStationInfo.saveStationPositionY = currentPosition.y;
        mainSaveStationInfo.saveStationPositionZ = currentPosition.z;
        mainSaveStationInfo.saveStationRotationX = currentEulerAngles.x;
        mainSaveStationInfo.saveStationRotationY = currentEulerAngles.y;
        mainSaveStationInfo.saveStationRotationZ = currentEulerAngles.z;

        if (usePlayerCameraOrientation && canUsePlayerCameraOrientation) {
            mainSaveStationInfo.usePlayerCameraOrientation = true;

            Vector3 cameraEulerAngles = playerCameraGameObject.transform.eulerAngles;

            mainSaveStationInfo.playerCameraRotationX = cameraEulerAngles.x;
            mainSaveStationInfo.playerCameraRotationY = cameraEulerAngles.y;
            mainSaveStationInfo.playerCameraRotationZ = cameraEulerAngles.z;

            Vector3 playerCameraPivotEulerRotation = mainPlayerCameraManager.getPivotCameraTransform ().localEulerAngles;

            mainSaveStationInfo.playerCameraPivotRotationX = playerCameraPivotEulerRotation.x;
        } else {
            mainSaveStationInfo.usePlayerCameraOrientation = false;
        }
    }

    public void activateSaveStation ()
    {
        usingSaveStation = !usingSaveStation;

        if (usingSaveStation) {

            loadStates ();

            saveMenu.SetActive (true);

            if (!animationName.Equals ("")) {
                stationAnimation.Stop ();
                stationAnimation [animationName].speed = 1;
                stationAnimation.Play (animationName);
            }

            resetScroll (scrollBar);
        } else {
            saveMenu.SetActive (false);

            if (!animationName.Equals ("")) {
                stationAnimation.Stop ();
                stationAnimation [animationName].speed = -1;
                stationAnimation [animationName].time = stationAnimation [animationName].length;
                stationAnimation.Play (animationName);
            }

            changeButtonsColor (false, false, false, false);
        }
    }

    public void openSaveGameMenu ()
    {
        loadStates ();

        changeButtonsColor (false, false, false, false);

        setSaveGameTransformInfo (saveStationPosition, true);

        resetScroll (scrollBar);
    }

    public void getSaveButtonSelected (Button button)
    {
        currentButtonIndex = -1;

        bool save = false;
        bool load = false;
        bool delete = false;

        for (int i = 0; i < saveGameListElements.Count; i++) {
            buttonInfo currentSaveButtonInfo = saveGameListElements [i];

            if (currentSaveButtonInfo.button == button) {
                currentButtonIndex = i;
                currentButton = button;

                if (currentSaveButtonInfo.infoAdded) {
                    load = true;
                }

                if (currentSaveButtonInfo.isCheckpointSave) {
                    if (checkpointSlotCanBeDeletedEnabled) {
                        if (currentSaveButtonInfo.infoAdded) {
                            delete = true;
                        }
                    }
                } else {
                    if (currentSaveButtonInfo.infoAdded) {
                        delete = true;
                    }

                    save = true;
                }
            }
        }

        changeButtonsColor (true, save, load, delete);
    }

    void deleteHiddenCheckpointSave ()
    {
        int currentSaveNumber = -1;

        for (int i = 0; i < saveGameListElements.Count; i++) {
            if (currentSaveNumber == -1) {
                canDelete = false;

                buttonInfo currentSaveButtonInfo = saveGameListElements [i];

                currentButtonIndex = i;
                currentButton = currentSaveButtonInfo.button;

                if (currentSaveButtonInfo.usedForAutoLoadSave) {
                    if (checkpointSlotCanBeDeletedEnabled) {
                        if (currentSaveButtonInfo.infoAdded) {
                            canDelete = true;

                            currentSaveNumber = i;
                        }
                    }
                }
            }
        }

        if (currentSaveNumber > -1) {
            deleteGame ();
        }

        List<saveStationInfo> saveList = loadFile ();

        int saveListCount = saveList.Count;

        if (saveListCount > 0) {
            for (int j = 0; j < saveListCount; j++) {
                saveStationInfo currentSave = saveList [j];

                bool saveInfoLocated = false;

                if (currentSaveNumber > -1) {
                    if (currentSave.saveNumber == currentSaveNumber) {
                        saveInfoLocated = true;
                    }
                } else {
                    if (currentSave.usedForAutoLoadSave) {
                        saveInfoLocated = true;

                        currentSaveNumber = currentSave.saveNumber;
                    }
                }

                if (saveInfoLocated) {
                    gameManagerComponent.deleteGameInfo (currentSaveNumber);

                    return;
                }
            }
        }
    }

    public void showSaveInfoDebug ()
    {
        if (showAllGameInfoDebug) {
            gameManagerComponent.showSaveInfoDebug (slotInfoNumberDebug);
        } else {
            List<saveStationInfo> saveList = loadFile ();

            int saveListCount = saveList.Count;

            if (saveListCount > 0) {
                for (int j = 0; j < saveListCount; j++) {
                    saveStationInfo currentSave = saveList [j];

                    if (currentSave.saveNumber == slotInfoNumberDebug) {

                        showSaveSlotInfo (currentSave, j);

                        gameManagerComponent.showSaveInfoDebug (slotInfoNumberDebug);

                        return;
                    }
                }
            }
        }
    }

    public void showSaveInfoDebug (int saveNumberToDelete, string currentSaveDataPath, string extraFileString)
    {
        int saveInfoListCount = saveInfoList.Count;

        for (int i = 0; i < saveInfoListCount; i++) {
            saveInfo currentSaveInfo = saveInfoList [i];

            if (currentSaveInfo.loadInfoEnabled) {

                string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                int playerID = defaultPlayerID;

                if (mainPlayerController != null) {
                    playerID = mainPlayerController.getPlayerID ();
                }

                currentSaveInfo.mainSaveGameInfo.showSaveInfoDebug (saveNumberToDelete, playerID,
                    newDataPath, showAllGameInfoDebug, true);
            }
        }
    }

    public void newGame ()
    {
        if (deleteHiddenCheckpointSaveOnNewGameEnabled) {
            deleteHiddenCheckpointSave ();
        }

        PlayerPrefs.SetInt ("loadingGame", 0);

        GKC_Utils.loadScene (sceneToLoadNewGame, useLoadScreen, loadScreenScene, sceneToLoadAsyncPrefsName,
            useLastSceneIndexAsLoadScreen, checkLoadingScreenSceneConfigured, loadingScreenSceneName);
    }

    public void continueGame ()
    {
        if (deleteHiddenCheckpointSaveOnContinueGameEnabled) {
            deleteHiddenCheckpointSave ();
        }

        saveStationInfo recentSave = new saveStationInfo ();

        List<saveStationInfo> saveList = loadFile ();

        long closestDate = 0;

        int saveListCount = saveList.Count;

        if (saveListCount > 0) {
            for (int j = 0; j < saveListCount; j++) {
                //print (saveList [j].saveDate.Ticks);

                saveStationInfo currentSave = saveList [j];

                if (!currentSave.usedForAutoLoadSave) {
                    if (currentSave.showSaveSlot && currentSave.saveDate.Ticks > closestDate) {
                        closestDate = currentSave.saveDate.Ticks;

                        recentSave = currentSave;
                    }
                }
            }

            if (showDebugInfo) {
                print ("continue Game, checking newer slot " + recentSave.saveDate + " " + recentSave.saveNumber);
            }

            gameManagerComponent.getPlayerPrefsInfo (recentSave);
        } else {
            print ("WARNING: the game hasn't been saved previously, so there is no game to continue yet");
        }
    }

    public void saveGameOnHiddenSlotIndex (int saveSlotIndex)
    {
        saveCurrentGame (saveSlotIndex, false, false, -1, -1, false, false, true);
    }

    public void setSavingGameManuallyActiveState (bool state)
    {
        savingGameManuallyActive = state;
    }

    public void saveGame ()
    {
        if (currentButton != null && canSave) {
            int saveSlotIndex = -1;

            for (int i = 0; i < saveGameListElements.Count; i++) {
                buttonInfo currentSaveButtonInfo = saveGameListElements [i];

                if (currentSaveButtonInfo.button == currentButton) {
                    currentSaveButtonInfo.infoAdded = true;

                    saveSlotIndex = i;
                }
            }

            savingGameManuallyActive = true;

            saveCurrentGame (saveSlotIndex, false, false, -1, -1, false, true, true);
        }

        savingGameManuallyActive = false;
    }

    public void playSavingGameAnimation ()
    {
        if (useCanvasGroupOnShowSavingGamePanel) {
            showSavingGamePanelInfo ();
        } else {
            savingGameAnimation.Stop ();
            savingGameAnimation [savingGameAnimationName].speed = animationSpeed;
            savingGameAnimation.Play (savingGameAnimationName);
        }
    }

    public void showSavingGamePanelInfo ()
    {
        if (savingIcon == null) {
            return;
        }

        if (savingGamePanelInfoCoroutine != null) {
            StopCoroutine (savingGamePanelInfoCoroutine);
        }

        savingGamePanelInfoCoroutine = StartCoroutine (showSavingGamePanelInfoCoroutine ());
    }

    IEnumerator showSavingGamePanelInfoCoroutine ()
    {
        CanvasGroup currentCanvasGroup = savingIcon.GetComponent<CanvasGroup> ();

        if (currentCanvasGroup != null) {
            savingIcon.SetActive (true);

            float targetValue = 1;

            while (currentCanvasGroup.alpha != targetValue) {
                currentCanvasGroup.alpha = Mathf.MoveTowards (currentCanvasGroup.alpha, targetValue, Time.deltaTime * showSavingGamePanelFadeSpeed);

                yield return null;
            }

            WaitForSeconds delay = new WaitForSeconds (showSavingGamePanelDuration);

            yield return delay;

            targetValue = 0;

            while (currentCanvasGroup.alpha != targetValue) {
                currentCanvasGroup.alpha = Mathf.MoveTowards (currentCanvasGroup.alpha, targetValue, Time.deltaTime * showSavingGamePanelFadeSpeed);

                yield return null;
            }

            savingIcon.SetActive (false);
        }

        yield return null;
    }


    public void saveGameCheckpoint (Transform customTransform, int checkpointID, int checkpointSceneID,
                                    bool overwriteThisCheckpointActive, bool savingGameToChangeScene,
                                    bool autoSaveGameOnSceneChangeEnabled)
    {
        int saveSlotIndex = -1;

        for (int i = 0; i < saveGameListElements.Count; i++) {
            if (savingGameToChangeScene) {
                if (saveGameListElements [i].usedForAutoLoadSave) {
                    saveSlotIndex = i;
                }
            } else {
                if (saveGameListElements [i].isCheckpointSave) {
                    saveSlotIndex = i;
                }
            }
        }

        List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

        if (!overwriteThisCheckpointActive) {

            int saveListCount = saveList.Count;

            for (int j = 0; j < saveListCount; j++) {
                saveStationInfo currentSave = saveList [j];

                if (currentSave.isCheckpointSave && currentSave.saveNumber == saveSlotIndex) {

                    if (showDebugInfo) {
                        print (currentSave.checkpointID + " " + checkpointID + " " + currentSave.checkpointSceneID + " " + checkpointSceneID);
                    }

                    if (currentSave.checkpointID == checkpointID && currentSave.checkpointSceneID == checkpointSceneID) {
                        if (showDebugInfo) {
                            print ("trying to save in the same checkpoint where the player has started, save canceled");
                        }

                        checkpointSystem checkpointManager = FindObjectOfType<checkpointSystem> ();

                        if (checkpointManager != null) {
                            checkpointManager.disableCheckPoint (checkpointID);
                        }

                        return;
                    }
                }
            }
        }

        bool useCustomSaveTransform = false;

        if (customTransform != null) {
            setSaveGameTransformInfo (customTransform, false);

            useCustomSaveTransform = true;
        } else {
            setSaveGameTransformInfo (saveStationPosition, true);
        }

        saveCurrentGame (saveSlotIndex, useCustomSaveTransform, true, checkpointID, checkpointSceneID, savingGameToChangeScene, true, autoSaveGameOnSceneChangeEnabled);

        if (useSavingIcon) {
            playSavingGameAnimation ();
        }
    }

    public void saveCurrentGame (int saveSlotIndex, bool useCustomSaveTransform, bool isCheckpointSave, int checkpointID,
                                 int checkpointSceneID, bool savingGameToChangeScene, bool showSaveSlot, bool saveGameInfoActive)
    {
        getPlayerComponents ();

        bool saveLocated = false;

        saveStationInfo newSave = new saveStationInfo (mainSaveStationInfo);

        List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

        int currentSaveNumber = 0;

        if (saveList.Count == 0) {
            saveList = loadFile ();

            gameManagerComponent.setSaveList (saveList);
        }

        int saveListCount = saveList.Count;

        for (int j = 0; j < saveListCount; j++) {
            if (saveList [j].saveNumber == saveSlotIndex && !saveLocated) {
                newSave = saveList [j];

                if (showDebugInfo) {
                    print ("Overwriting a previous slot " + saveSlotIndex + " " + j);
                }

                saveLocated = true;

                currentSaveNumber = saveSlotIndex;
                //print ("save found");
            }
        }

        newSave.saveStationPositionX = mainSaveStationInfo.saveStationPositionX;
        newSave.saveStationPositionY = mainSaveStationInfo.saveStationPositionY;
        newSave.saveStationPositionZ = mainSaveStationInfo.saveStationPositionZ;
        newSave.saveStationRotationX = mainSaveStationInfo.saveStationRotationX;
        newSave.saveStationRotationY = mainSaveStationInfo.saveStationRotationY;
        newSave.saveStationRotationZ = mainSaveStationInfo.saveStationRotationZ;

        if (usePlayerCameraOrientation) {
            newSave.playerCameraRotationX = mainSaveStationInfo.playerCameraRotationX;
            newSave.playerCameraRotationY = mainSaveStationInfo.playerCameraRotationY;
            newSave.playerCameraRotationZ = mainSaveStationInfo.playerCameraRotationZ;

            newSave.playerCameraPivotRotationX = mainSaveStationInfo.playerCameraPivotRotationX;
        }

        if (!saveLocated) {
            //print ("new save");
            newSave.playTime = gameManagerComponent.getPlayTime ();
        } else {
            newSave.playTime += gameManagerComponent.getPlayTime ();
        }

        if (isPhysicalSaveStation || useCustomSaveTransform) {
            newSave.useRaycastToPlacePlayer = true;
        }

        newSave.usePlayerCameraOrientation = mainSaveStationInfo.usePlayerCameraOrientation;

        newSave.isCheckpointSave = isCheckpointSave;
        newSave.checkpointID = checkpointID;
        newSave.checkpointSceneID = checkpointSceneID;

        gameManagerComponent.setPlayTimeValue (0);

        newSave.chapterNumberAndName = gameManagerComponent.getChapterName ();

        newSave.saveNumber = saveSlotIndex;

        newSave.saveDate = System.DateTime.Now;

        newSave.showSaveSlot = showSaveSlot;

        if (savingGameToChangeScene) {
            newSave.saveStationScene = checkpointSceneID;
        } else {
            newSave.saveStationScene = mainSaveStationInfo.saveStationScene;
        }

        if (mainPlayerController != null && mainPlayerController.isPlayerDriving ()) {
            string vehicleName = mainPlayerController.getCurrentVehicleName ();

            GameObject currentVehicle = mainPlayerController.getCurrentVehicle ();

            if (currentVehicle != null) {
                elementOnSceneHelper vehicleElementOnSceneHelper = currentVehicle.GetComponentInChildren<elementOnSceneHelper> ();

                if (vehicleElementOnSceneHelper != null) {
                    vehicleElementOnSceneHelper.setElementActiveState (false);

                    newSave.currentVehicleElementScene = vehicleElementOnSceneHelper.getElementScene ();
                    newSave.currentVehicleElementID = vehicleElementOnSceneHelper.getElementID ();
                }
            }

            newSave.isPlayerDriving = true;
            newSave.currentVehicleName = vehicleName;
        } else {
            newSave.isPlayerDriving = false;
        }

        newSave.savingGameToChangeScene = savingGameToChangeScene;

        newSave.usedForAutoLoadSave = savingGameToChangeScene;

        if (!saveLocated) {
            saveList.Add (newSave);

            currentSaveNumber = saveSlotIndex;
        }

        showSaveList (saveList);

        if (gameManagerComponent != null && gameManagerComponent.saveCameraCapture) {
            saveCameraView (newSave.saveNumber.ToString ());
        }

        if (!isCheckpointSave && showSaveSlot) {
            updateSaveSlotContent (saveSlotIndex, newSave);
        }

        gameManagerComponent.setSaveList (saveList);

        BinaryFormatter bf = new BinaryFormatter ();

        FileStream file = File.Create (currentSaveDataPath + currentSaveDataName + ".txt");

        bf.Serialize (file, saveList);

        file.Close ();

        changeButtonsColor (false, false, false, false);


        if (saveGameInfoActive) {
            //Save the info of the list element configured specifically to save different values from different components
            if (saveInfoList.Count == 0) {
                saveInfoList = mainPlayerComponentsManager.getSaveGameSystem ().getSaveInfoList ();
            }

            string extraFileString = " " + gameManagerComponent.getVersionNumber () + gameManagerComponent.getFileExtension ();

            int saveInfoListCount = saveInfoList.Count;

            int usedForAutoLoadSaveIndex = -1;

            if (savingGameManuallyActive) {
                saveListCount = saveList.Count;

                for (int j = 0; j < saveListCount; j++) {
                    saveStationInfo currentSave = saveList [j];

                    if (currentSave.usedForAutoLoadSave) {
                        usedForAutoLoadSaveIndex = currentSave.saveNumber;
                    }
                }
            }

            for (int i = 0; i < saveInfoListCount; i++) {
                saveInfo currentSaveInfo = saveInfoList [i];

                if (currentSaveInfo.saveInfoEnabled) {

                    string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                    int playerID = defaultPlayerID;

                    if (mainPlayerController != null) {
                        playerID = mainPlayerController.getPlayerID ();
                    }

                    currentSaveInfo.mainSaveGameInfo.saveGame (currentSaveNumber, playerID, newDataPath,
                        (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnSave), savingGameToChangeScene);

                    if (savingGameManuallyActive) {
                        currentSaveInfo.mainSaveGameInfo.copyGameInfo (currentSaveNumber, usedForAutoLoadSaveIndex,
                            playerID, newDataPath, false, (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnSave));
                    }
                }
            }
        }

        if (mainPlayerCameraManager != null) {
            mainPlayerCameraManager.updateCameraList ();
        }

        if (useEventOnSaveGame) {
            eventOnSaveGame.Invoke (saveSlotIndex);
        }

        savingGameManuallyActive = false;
    }

    public void saveCustomInfoList (string listName)
    {
        int currentIndex = customSaveListInfoList.FindIndex (s => s.Name == listName);

        if (currentIndex > -1) {
            customSaveListInfo currentCustomSaveListInfo = customSaveListInfoList [currentIndex];

            if (!currentCustomSaveListInfo.saveListInfoEnabled) {
                return;
            }

            //Save the info of the list element configured specifically to save different values from different components
            if (saveInfoList.Count == 0) {
                saveInfoList = mainPlayerComponentsManager.getSaveGameSystem ().getSaveInfoList ();
            }

            string extraFileString = " " + gameManagerComponent.getVersionNumber () + gameManagerComponent.getFileExtension ();

            int saveInfoListCount = saveInfoList.Count;


            for (int i = 0; i < saveInfoListCount; i++) {
                saveInfo currentSaveInfo = saveInfoList [i];

                if (currentSaveInfo.saveInfoEnabled && currentCustomSaveListInfo.customSaveGameInfoList.Contains (currentSaveInfo.Name)) {

                    string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                    int playerID = defaultPlayerID;

                    if (mainPlayerController != null) {
                        playerID = mainPlayerController.getPlayerID ();
                    }

                    currentSaveInfo.mainSaveGameInfo.saveGame (currentCustomSaveListInfo.saveNumber, playerID,
                        newDataPath, (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnSave), false);
                }
            }
        }
    }

    public void saveGameInfoFromEditor (int saveNumberToLoad, string infoTypeName, string extraFileString)
    {
        int saveInfoListCount = saveInfoList.Count;

        for (int i = 0; i < saveInfoListCount; i++) {
            saveInfo currentSaveInfo = saveInfoList [i];

            if (currentSaveInfo.saveInfoEnabled && currentSaveInfo.Name.Equals (infoTypeName)) {

                string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                currentSaveInfo.mainSaveGameInfo.saveGameFromEditor (saveNumberToLoad, mainPlayerController.getPlayerID (), newDataPath, currentSaveInfo.showDebugInfo);

                return;
            }
        }
    }

    public void saveGameOnCheckpointSlot ()
    {
        saveGameWhenReturningHomeMenu ();
    }

    public void saveGameWhenReturningHomeMenu ()
    {
        savingGameManuallyActive = true;

        saveGameCheckpoint (null, 0, 0, overwriteCheckpointSlotWhenSavingOnReturnToHome, false, true);

        savingGameManuallyActive = false;
    }

    public List<saveInfo> getSaveInfoList ()
    {
        return saveInfoList;
    }

    public void checkGameInfoToLoad (int lastSaveNumber, string currentSaveDataPath, string extraFileString)
    {
        int saveInfoListCount = saveInfoList.Count;

        //checking if the load game has been made manually or is an auto load from moving in between scenes
        bool usedForAutoLoadSave = false;

        int usedForAutoLoadSaveIndex = -1;

        if (lastSaveNumber <= gameManagerComponent.getSlotBySaveStation () + 5) {
            List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

            if (saveList.Count == 0) {
                saveList = loadFile ();

                if (saveList.Count > 0) {
                    gameManagerComponent.setSaveList (saveList);
                }
            }

            int saveListCount = saveList.Count;

            if (saveListCount > 0) {
                for (int j = 0; j < saveListCount; j++) {
                    saveStationInfo currentSave = saveList [j];

                    if (currentSave.saveNumber == lastSaveNumber) {
                        usedForAutoLoadSave = currentSave.usedForAutoLoadSave;
                    }

                    if (currentSave.usedForAutoLoadSave) {
                        usedForAutoLoadSaveIndex = currentSave.saveNumber;
                    }
                }
            }
        }

        if (showDebugInfo) {
            print ("usedForAutoLoadSave " + usedForAutoLoadSave + " " + usedForAutoLoadSaveIndex + " " + lastSaveNumber);
        }

        for (int i = 0; i < saveInfoListCount; i++) {
            saveInfo currentSaveInfo = saveInfoList [i];

            if (currentSaveInfo.loadInfoEnabled) {

                string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                int playerID = defaultPlayerID;

                if (mainPlayerController != null) {
                    playerID = mainPlayerController.getPlayerID ();
                }

                currentSaveInfo.mainSaveGameInfo.loadGame (lastSaveNumber, playerID,
                    newDataPath, (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnLoad));

                if (!usedForAutoLoadSave && usedForAutoLoadSaveIndex != -1) {
                    currentSaveInfo.mainSaveGameInfo.copyGameInfo (usedForAutoLoadSaveIndex, lastSaveNumber,
                        playerID, newDataPath, true, (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnSave));
                }
            }
        }

        // StartCoroutine (showCheckGameInfoToLoadInfo (lastSaveNumber));

    }

    //IEnumerator showCheckGameInfoToLoadInfo (int lastSaveNumber)
    //{
    //    WaitForSeconds delay = new WaitForSeconds (0.3f);

    //    yield return delay;

    //    List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

    //    if (saveList.Count == 0) {

    //        saveList = loadFile ();

    //        if (saveList.Count > 0) {
    //            gameManagerComponent.setSaveList (saveList);
    //        }
    //    }

    //    int saveListCount = saveList.Count;

    //    for (int j = 0; j < saveListCount; j++) {
    //        showSaveSlotInfo (saveList [j], j);
    //    }

    //    print (lastSaveNumber + " " + saveListCount);

    //}

    public void deleteGameInfo (int saveNumberToDelete, string currentSaveDataPath, string extraFileString)
    {
        int saveInfoListCount = saveInfoList.Count;

        for (int i = 0; i < saveInfoListCount; i++) {
            saveInfo currentSaveInfo = saveInfoList [i];

            if (currentSaveInfo.loadInfoEnabled) {

                string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                int playerID = defaultPlayerID;

                if (mainPlayerController != null) {
                    playerID = mainPlayerController.getPlayerID ();
                }

                currentSaveInfo.mainSaveGameInfo.deleteGameInfo (saveNumberToDelete, playerID,
                    newDataPath, (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnLoad));
            }
        }
    }

    public void checkComponentsToInitialize ()
    {
        int saveInfoListCount = saveInfoList.Count;

        for (int i = 0; i < saveInfoListCount; i++) {
            saveInfo currentSaveInfo = saveInfoList [i];

            if (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnLoad) {
                print ("initializing values on " + currentSaveInfo.Name);
            }

            currentSaveInfo.mainSaveGameInfo.initializeValuesOnComponent ();
        }
    }

    public void checkSaveInfoListToLoadOnStartOnAllScenes ()
    {
        if (!saveInfoListToLoadOnStartOnAllScenesEnabled) {
            return;
        }

        int saveInfoListToLoadOnStartOnAllScenesCount = saveInfoListToLoadOnStartOnAllScenes.Count;

        if (saveInfoListToLoadOnStartOnAllScenesCount == 0) {
            return;
        }

        if (currentSaveDataPath == "") {
            currentSaveDataPath = gameManagerComponent.getDataPath ();
        }

        string extraFileString = " " + gameManagerComponent.getVersionNumber () + gameManagerComponent.getFileExtension ();

        for (int i = 0; i < saveInfoListToLoadOnStartOnAllScenesCount; i++) {
            saveInfo currentSaveInfo = saveInfoListToLoadOnStartOnAllScenes [i];

            if (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnLoad) {
                print ("loading values on start on " + currentSaveInfo.Name);
            }

            if (currentSaveInfo.loadInfoEnabled) {

                string newDataPath = currentSaveDataPath + currentSaveInfo.saveFileName + extraFileString;

                currentSaveInfo.mainSaveGameInfo.checkSaveInfoToLoadOnStartOnAllScenes (saveNumberToLoadOnStartOnAllScenes, 0,
                    newDataPath, (currentSaveInfo.showDebugInfo && !ignoreShowDebugInfoOnLoad));
            }
        }
    }

    public void updateSaveSlotContent (int saveSlotIndex, saveStationInfo newSave)
    {
        buttonInfo currentSaveButtonInfo = saveGameListElements [saveSlotIndex];

        if (gameManagerComponent != null && gameManagerComponent.saveCameraCapture) {
            currentSaveButtonInfo.icon.enabled = true;

#if !UNITY_WEBPLAYER

            string fullFileName = currentSaveDataPath + (currentSaveDataName + "_" + newSave.saveNumber + ".png");

            if (File.Exists (fullFileName)) {
                byte [] bytes = File.ReadAllBytes (fullFileName);
                Texture2D texture = new Texture2D ((int)captureResolution.x, (int)captureResolution.y);
                texture.filterMode = FilterMode.Trilinear;
                texture.LoadImage (bytes);

                currentSaveButtonInfo.icon.texture = texture;
            }

#endif
        }

        currentSaveButtonInfo.chapterName.text = getLocalizedText (newSave.chapterNumberAndName);

        currentSaveButtonInfo.playTime.text = convertSecondsIntoHours (newSave.playTime);

        currentSaveButtonInfo.saveNumber.text = getLocalizedText (saveTextField) + " " + (newSave.saveNumber + 1);

        currentSaveButtonInfo.saveDate.text = String.Format ("{0:dd/MM/yy}", newSave.saveDate);

        currentSaveButtonInfo.saveHour.text = newSave.saveDate.Hour.ToString ("00") + ":" + newSave.saveDate.Minute.ToString ("00");
    }

    public void reloadLastCheckpoint ()
    {
        bool checkpointSlotFound = false;

        currentButtonIndex = -1;

        for (int i = 0; i < saveGameListElements.Count; i++) {
            buttonInfo currentSaveButtonInfo = saveGameListElements [i];

            if (!checkpointSlotFound) {
                if (currentSaveButtonInfo.isCheckpointSave && !currentSaveButtonInfo.usedForAutoLoadSave) {

                    currentButtonIndex = i;

                    currentButton = currentSaveButtonInfo.button;

                    canLoad = true;

                    checkpointSlotFound = true;

                    loadGame ();
                }
            }
        }
    }

    public void activateAutoLoad ()
    {
        bool checkpointSlotFound = false;

        currentButtonIndex = -1;

        for (int i = 0; i < saveGameListElements.Count; i++) {
            buttonInfo currentSaveButtonInfo = saveGameListElements [i];

            if (!checkpointSlotFound) {
                if (currentSaveButtonInfo.usedForAutoLoadSave) {

                    currentButtonIndex = i;

                    currentButton = currentSaveButtonInfo.button;

                    canLoad = true;

                    checkpointSlotFound = true;

                    loadGame ();
                }
            }
        }
    }

    public void loadGameBySlotIndex (int slotIndexToLoad)
    {
        if (slotIndexToLoad < saveGameListElements.Count) {
            currentButtonIndex = slotIndexToLoad;

            buttonInfo currentSaveButtonInfo = saveGameListElements [currentButtonIndex];

            currentButton = currentSaveButtonInfo.button;

            canLoad = true;

            loadGame ();
        }
    }

    public void loadGame ()
    {
        if (currentButton != null && canLoad) {
            saveStationInfo newSave = new saveStationInfo (mainSaveStationInfo);

            List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

            if (saveList.Count == 0) {

                saveList = loadFile ();

                gameManagerComponent.setSaveList (saveList);
            }

            int saveListCount = saveList.Count;

            for (int j = 0; j < saveListCount; j++) {
                if (saveList [j].saveNumber == currentButtonIndex) {
                    newSave = new saveStationInfo (saveList [j]);
                    //print ("save loaded");

                    if (showDebugInfo) {
                        showSaveSlotInfo (newSave, j);
                    }
                }
            }

            gameManagerComponent.getPlayerPrefsInfo (newSave);

            if (useEventOnLoadGame) {
                eventOnLoadGame.Invoke (newSave.saveNumber);
            }
        }
    }

    public void deleteAllGames ()
    {
        for (int i = 0; i < saveGameListElements.Count; i++) {
            canDelete = false;

            buttonInfo currentSaveButtonInfo = saveGameListElements [i];

            currentButtonIndex = i;
            currentButton = currentSaveButtonInfo.button;

            if (currentSaveButtonInfo.isCheckpointSave) {
                if (checkpointSlotCanBeDeletedEnabled) {
                    if (currentSaveButtonInfo.infoAdded) {
                        canDelete = true;
                    }
                }
            } else {
                if (currentSaveButtonInfo.infoAdded) {
                    canDelete = true;
                }
            }

            if (canDelete) {
                deleteGame ();
            }
        }
    }

    public void deleteGame ()
    {
        if (currentButton != null && canDelete) {
            bool saveLocated = false;

            saveStationInfo newSave = new saveStationInfo (mainSaveStationInfo);

            List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

            if (saveList.Count == 0) {
                saveList = loadFile ();

                gameManagerComponent.setSaveList (saveList);
            }

            int saveListCount = saveList.Count;

            for (int j = 0; j < saveListCount; j++) {
                if (saveList [j].saveNumber == currentButtonIndex) {
                    newSave = saveList [j];

                    saveLocated = true;

                    //print ("save deleted");
                }
            }

            string fileName = currentSaveDataPath + (currentSaveDataName + "_" + newSave.saveNumber + ".png");

            if (File.Exists (fileName)) {
                File.Delete (fileName);
            }

            if (saveLocated) {
                saveList.Remove (newSave);
            }

            showSaveList (saveList);

            buttonInfo currentSaveButtonInfo = saveGameListElements [currentButtonIndex];

            currentSaveButtonInfo.icon.enabled = false;
            currentSaveButtonInfo.chapterName.text = getLocalizedText (chapterTextField) + " -";
            currentSaveButtonInfo.saveNumber.text = getLocalizedText (saveTextField) + " -";
            currentSaveButtonInfo.playTime.text = "--:--:--";
            currentSaveButtonInfo.saveDate.text = "--/--/--";
            currentSaveButtonInfo.saveHour.text = "--:--";

            if (currentSaveButtonInfo.isCheckpointSave) {
                currentSaveButtonInfo.slotGameObject.SetActive (false);

                scrollBar.value = 0;
            }

            BinaryFormatter bf = new BinaryFormatter ();

            FileStream file = File.Create (currentSaveDataPath + currentSaveDataName + ".txt");

            bf.Serialize (file, saveList);

            file.Close ();

            changeButtonsColor (false, false, false, false);
        }
    }

    public void changeButtonsColor (bool state, bool save, bool load, bool delete)
    {
        if (saveButton != null) {
            if (save) {
                saveButton.color = originalColor;
            } else {
                saveButton.color = disableButtonsColor;
            }
        }

        if (load) {
            loadButton.color = originalColor;
        } else {
            loadButton.color = disableButtonsColor;
        }

        if (delete) {
            deleteButton.color = originalColor;
        } else {
            deleteButton.color = disableButtonsColor;
        }

        canSave = save;
        canLoad = load;
        canDelete = delete;

        if (!state) {
            currentButton = null;
        }
    }

    public void loadStates ()
    {
        List<saveStationInfo> saveList = gameManagerComponent.getCurrentSaveList ();

        if (saveList.Count == 0) {

            saveList = loadFile ();

            gameManagerComponent.setSaveList (saveList);
        }

        showSaveList (saveList);

        for (int i = 0; i < saveGameListElements.Count; i++) {
            buttonInfo currentSaveButtonInfo = saveGameListElements [i];

            int saveListCount = saveList.Count;

            for (int j = 0; j < saveListCount; j++) {
                saveStationInfo currentSaveStationInfo = saveList [j];

                if (currentSaveStationInfo.saveNumber == i) {

                    updateSaveSlotContent (i, currentSaveStationInfo);

                    currentSaveButtonInfo.infoAdded = true;

                    if (currentSaveStationInfo.isCheckpointSave && !currentSaveStationInfo.usedForAutoLoadSave) {
                        currentSaveButtonInfo.slotGameObject.SetActive (true);
                    }
                }
            }
        }

        for (int i = 0; i < saveGameListElements.Count; i++) {
            buttonInfo currentSaveButtonInfo = saveGameListElements [i];

            if (!currentSaveButtonInfo.infoAdded) {
                currentSaveButtonInfo.icon.enabled = false;
                currentSaveButtonInfo.chapterName.text = getLocalizedText (chapterTextField) + " -";
                currentSaveButtonInfo.saveNumber.text = getLocalizedText (saveTextField) + " -";
                currentSaveButtonInfo.playTime.text = "--:--:--";
                currentSaveButtonInfo.saveDate.text = "--/--/--";
                currentSaveButtonInfo.saveHour.text = "--:--";
            }

            if (!manualSaveEnabled) {
                if (!currentSaveButtonInfo.isCheckpointSave) {
                    if (currentSaveButtonInfo.slotGameObject.activeSelf) {
                        currentSaveButtonInfo.slotGameObject.SetActive (false);
                    }
                }
            }
        }
    }

    string getLocalizedText (string textContent)
    {
        if (gameLanguageSelector.isCheckLanguageActive ()) {
            textContent = interactionObjectsLocalizationManager.GetLocalizedValue (textContent);
        }

        return textContent;
    }

    void saveCameraView (string saveNumber)
    {
        if (photoCapturer == null) {

            if (mainPlayerCameraManager != null) {
                photoCapturer = mainPlayerCameraManager.getMainCamera ();
            }

            if (photoCapturer == null) {
                return;
            }
        }

        // get the camera's render texture
        setPhotoCapturerState (true);

        photoCapturer.targetTexture = new RenderTexture ((int)captureResolution.x, (int)captureResolution.y, 24);
        RenderTexture rendText = RenderTexture.active;
        RenderTexture.active = photoCapturer.targetTexture;

        // render the texture
        photoCapturer.Render ();
        // create a new Texture2D with the camera's texture, using its height and width
        Texture2D cameraImage = new Texture2D ((int)captureResolution.x, (int)captureResolution.y, TextureFormat.RGB24, false);
        cameraImage.ReadPixels (new Rect (0, 0, (int)captureResolution.x, (int)captureResolution.y), 0, 0);

        cameraImage.Apply ();

        RenderTexture.active = rendText;

        // store the texture into a .PNG file
#if !UNITY_WEBPLAYER

        byte [] bytes = cameraImage.EncodeToPNG ();

        // save the encoded image to a file
        System.IO.File.WriteAllBytes (currentSaveDataPath + (currentSaveDataName + "_" + saveNumber + ".png"), bytes);

#endif

        photoCapturer.targetTexture = null;

        setPhotoCapturerState (false);
    }

    public void setPhotoCapturerState (bool state)
    {
        if (isPhysicalSaveStation) {
            photoCapturer.enabled = state;
        }
    }

    string convertSecondsIntoHours (float value)
    {
        TimeSpan timeSpan = TimeSpan.FromSeconds (value);

        string timeText = string.Format ("{0:D2}:{1:D2}:{2:D2}", timeSpan.Hours, timeSpan.Minutes, timeSpan.Seconds);

        return timeText;
    }

    public List<saveStationInfo> loadFile ()
    {
        List<saveStationInfo> saveList = new List<saveStationInfo> ();

        if (currentSaveDataPath == "") {
            currentSaveDataPath = gameManagerComponent.getDataPath ();
        }

        if (currentSaveDataName == "") {
            currentSaveDataName = gameManagerComponent.getDataName ();
        }

        string fullFileName = currentSaveDataPath + currentSaveDataName + ".txt";

        if (File.Exists (fullFileName)) {
            BinaryFormatter bf = new BinaryFormatter ();

            FileStream file = File.Open (fullFileName, FileMode.Open);

            saveList = (List<saveStationInfo>)bf.Deserialize (file);

            file.Close ();
        }

        return saveList;
    }

    public bool isThereSaveSlotsLoaded ()
    {
        List<saveGameSystem.saveStationInfo> saveList = loadFile ();

        int saveListCount = saveList.Count;

        for (int j = 0; j < saveListCount; j++) {
            saveStationInfo currentSaveInfo = saveList [j];

            if (currentSaveInfo.showSaveSlot) {
                return true;
            }
        }

        return false;
    }

    public void setStationIde (int idValue)
    {
        mainSaveStationInfo.id = idValue;
    }

    public void showSaveList (List<saveStationInfo> saveList)
    {
        if (!showDebugInfo) {
            return;
        }

        int saveListCount = saveList.Count;

        for (int i = 0; i < saveListCount; i++) {
            showSaveSlotInfo (saveList [i], i);
        }
    }

    public void showSaveSlotInfo (saveStationInfo saveSlot, int saveIndex)
    {
        print ("SAVE " + saveIndex);
        print ("Chapter " + saveSlot.chapterNumberAndName);
        print ("Position " + saveSlot.saveStationPositionX + " " + saveSlot.saveStationPositionY + " " + saveSlot.saveStationPositionZ);
        print ("Scene Index " + saveSlot.saveStationScene);
        print ("Id " + saveSlot.id);
        print ("Save Number " + saveSlot.saveNumber);
        print ("PlayTime " + saveSlot.playTime);
        print ("Date " + saveSlot.saveDate);
        print ("Hour " + saveSlot.saveDate.Hour + ":" + saveSlot.saveDate.Minute);
        print ("Changing of scene " + saveSlot.savingGameToChangeScene);
        print ("\n");
    }

    public void getPlayerComponents ()
    {
        if (playerControllerGameObject == null && electronicDeviceManager != null) {
            playerControllerGameObject = electronicDeviceManager.getCurrentPlayer ();

            mainPlayerComponentsManager = playerControllerGameObject.GetComponent<playerComponentsManager> ();

            mainPlayerController = mainPlayerComponentsManager.getPlayerController ();

            mainPlayerCameraManager = mainPlayerComponentsManager.getPlayerCamera ();
        }
    }

    public void resetScroll (Scrollbar scrollBarToReset)
    {
        StartCoroutine (resetScrollCoroutine (scrollBarToReset));
    }

    IEnumerator resetScrollCoroutine (Scrollbar scrollBarToReset)
    {
        yield return new WaitForEndOfFrame ();
        yield return new WaitForEndOfFrame ();

        if (scrollBarToReset != null) {
            scrollBarToReset.value = 1;
        }
    }

    public int getLastSaveSlotIndex ()
    {
        return saveGameListElements.Count - 1;
    }

    [System.Serializable]
    public class saveStationInfo
    {
        public string chapterNumberAndName;
        public float saveStationPositionX;
        public float saveStationPositionY;
        public float saveStationPositionZ;
        public float saveStationRotationX;
        public float saveStationRotationY;
        public float saveStationRotationZ;

        public bool usePlayerCameraOrientation;
        public float playerCameraRotationX;
        public float playerCameraRotationY;
        public float playerCameraRotationZ;

        public float playerCameraPivotRotationX;

        public int saveStationScene;

        public bool isPlayerDriving;
        public string currentVehicleName;

        public int currentVehicleElementScene;
        public int currentVehicleElementID;

        public int id;
        public int saveNumber;
        public float playTime;
        public DateTime saveDate;

        public bool showSaveSlot;

        public bool useRaycastToPlacePlayer;

        public bool isCheckpointSave;

        public int checkpointID;

        public int checkpointSceneID;

        public bool savingGameToChangeScene;

        public bool usedForAutoLoadSave;

        public saveStationInfo ()
        {

        }

        public saveStationInfo (saveStationInfo newSaveStationInfo)
        {
            chapterNumberAndName = newSaveStationInfo.chapterNumberAndName;
            saveStationPositionX = newSaveStationInfo.saveStationPositionX;
            saveStationPositionY = newSaveStationInfo.saveStationPositionY;
            saveStationPositionZ = newSaveStationInfo.saveStationPositionZ;
            saveStationRotationX = newSaveStationInfo.saveStationRotationX;
            saveStationRotationY = newSaveStationInfo.saveStationRotationY;
            saveStationRotationZ = newSaveStationInfo.saveStationRotationZ;

            usePlayerCameraOrientation = newSaveStationInfo.usePlayerCameraOrientation;
            playerCameraRotationX = newSaveStationInfo.playerCameraRotationX;
            playerCameraRotationY = newSaveStationInfo.playerCameraRotationY;
            playerCameraRotationZ = newSaveStationInfo.playerCameraRotationZ;

            playerCameraPivotRotationX = newSaveStationInfo.playerCameraPivotRotationX;

            saveStationScene = newSaveStationInfo.saveStationScene;

            isPlayerDriving = newSaveStationInfo.isPlayerDriving;
            currentVehicleName = newSaveStationInfo.currentVehicleName;
            currentVehicleElementScene = newSaveStationInfo.currentVehicleElementScene;
            currentVehicleElementID = newSaveStationInfo.currentVehicleElementID;

            id = newSaveStationInfo.id;
            saveNumber = newSaveStationInfo.saveNumber;
            playTime = newSaveStationInfo.playTime;
            saveDate = newSaveStationInfo.saveDate;

            showSaveSlot = newSaveStationInfo.showSaveSlot;

            useRaycastToPlacePlayer = newSaveStationInfo.useRaycastToPlacePlayer;

            isCheckpointSave = newSaveStationInfo.isCheckpointSave;

            usedForAutoLoadSave = newSaveStationInfo.usedForAutoLoadSave;

            checkpointID = newSaveStationInfo.checkpointID;

            checkpointSceneID = newSaveStationInfo.checkpointSceneID;

            savingGameToChangeScene = newSaveStationInfo.savingGameToChangeScene;
        }
    }

    [System.Serializable]
    public class buttonInfo
    {
        public GameObject slotGameObject;
        public Button button;
        public RawImage icon;
        public Text chapterName;
        public Text playTime;
        public Text saveNumber;
        public Text saveDate;
        public Text saveHour;
        public bool infoAdded;
        public bool isCheckpointSave;

        public bool usedForAutoLoadSave;
    }

    [System.Serializable]
    public class customSaveListInfo
    {
        public string Name;

        public bool saveListInfoEnabled = true;

        public int saveNumber;

        public List<string> customSaveGameInfoList = new List<string> ();
    }
}