using Godot;
using System.Collections.Generic;

public static class SaveGameDataApplier
{
    public static void ApplyWorldData(SaveGameData saveGame)
    {
        if (saveGame == null) return;

        GameData.seed = saveGame.Seed;
        GameData.currentLayer = saveGame.CurrentLayer;
        GameData.visibleLayer = saveGame.VisibleLayer;
        GameData.lowestLayer = saveGame.LowestLayer;
        GameData.maxRobotCount = saveGame.MaxRobotCount;
        GameData.canMove = saveGame.CanMove;

        ApplySettingsData(saveGame.Settings);
        ApplySurvivalData(saveGame.Survival);
        ApplyInventoryData(saveGame.Inventory);
        ApplyResearchData(saveGame.Research);
        ApplyLayerData(saveGame.Layers);
    }

    private static void ApplySurvivalData(SurvivalSaveData survival)
    {
        if (survival == null) return;

        GameData.survival.hunger = survival.Hunger;
        GameData.survival.thirst = survival.Thirst;
        GameData.survival.energy = survival.Energy;
        GameData.survival.isDead = survival.IsDead;
        GameData.survival.deathReason = survival.DeathReason ?? "";
        GameData.survival.currentStatus = survival.CurrentStatus ?? "";
        GameData.survival.elapsedSeconds = survival.ElapsedSeconds;
    }

    private static void ApplySettingsData(SettingsSaveData settings)
    {
        if (settings == null) return;

        GameData.screenMode = settings.ScreenMode;
        GameData.soundVolume = settings.SoundVolume;
        GameData.lightColor = new Color(
            settings.LightColorR,
            settings.LightColorG,
            settings.LightColorB,
            settings.LightColorA
        );

        ApplyScreenMode(settings.ScreenMode);
        SoundManager.SetMasterVolume(settings.SoundVolume);
        LightHandler.RedrawLights(GameData.lightColor);
    }

    private static void ApplyScreenMode(int screenMode)
    {
        switch (screenMode)
        {
            case 0:
                DisplayServer.WindowSetMode(DisplayServer.WindowMode.Fullscreen);
                DisplayServer.WindowSetFlag(DisplayServer.WindowFlags.Borderless, false);
                break;
            case 1:
                DisplayServer.WindowSetMode(DisplayServer.WindowMode.Windowed);
                DisplayServer.WindowSetFlag(DisplayServer.WindowFlags.Borderless, false);
                break;
            case 2:
                DisplayServer.WindowSetMode(DisplayServer.WindowMode.Fullscreen);
                DisplayServer.WindowSetFlag(DisplayServer.WindowFlags.Borderless, true);
                break;
            default:
                DisplayServer.WindowSetMode(DisplayServer.WindowMode.Windowed);
                DisplayServer.WindowSetFlag(DisplayServer.WindowFlags.Borderless, false);
                break;
        }
    }

    private static void ApplyInventoryData(List<ItemSaveData> savedItems)
    {
        GameData.inventory = new Inventory();
        if (savedItems == null) return;

        foreach (ItemSaveData savedItem in savedItems)
        {
            if (!GameData.availableItems.ContainsKey(savedItem.Id)) continue;

            GameData.inventory.AddItem(
                new Item { data = GameData.availableItems[savedItem.Id] },
                savedItem.Amount
            );
        }
    }

    private static void ApplyResearchData(List<ResearchSaveData> savedResearch)
    {
        if (savedResearch == null) return;

        foreach (ResearchSaveData savedState in savedResearch)
        {
            if (!GameData.availableResearch.ContainsKey(savedState.Id)) continue;

            Research research = GameData.availableResearch[savedState.Id];
            research.state = savedState.State;
            research.elapsedResearchTime = savedState.ElapsedResearchTime;
            research.paidResources = savedState.PaidResources;
        }

        GameData.RebuildRobotStatsFromResearch();
    }

    private static void ApplyLayerData(List<LayerSaveData> savedLayers)
    {
        if (savedLayers == null || GameData.map == null) return;

        foreach (LayerSaveData savedLayer in savedLayers)
        {
            if (savedLayer.Level < 0 || savedLayer.Level >= GameData.map.Length) continue;

            Layer layer = GameData.map[savedLayer.Level];
            layer.isGateOpen = savedLayer.IsGateOpen;
            layer.hasContentGenerated = savedLayer.HasContentGenerated;
            layer.gateIngredients = savedLayer.GateIngredients ?? new List<Ingredient>();
            layer.currentResources = savedLayer.CurrentResources ?? new List<string>();

            ApplyTileData(layer, savedLayer.Tiles);
        }
    }

    private static void ApplyTileData(Layer layer, List<TileSaveData> savedTiles)
    {
        if (savedTiles == null) return;

        foreach (TileSaveData savedTile in savedTiles)
        {
            if (savedTile.X < 0 || savedTile.X >= GameData.layerSize) continue;
            if (savedTile.Y < 0 || savedTile.Y >= GameData.layerSize) continue;

            Tile tile = layer.tiles[savedTile.X, savedTile.Y];
            tile.collapsedMesh = savedTile.CollapsedMesh;
            tile.containsLight = savedTile.ContainsLight;
            tile.containsDecoration = savedTile.ContainsDecoration;
            tile.containsResource = savedTile.ContainsResource;
            tile.wasVisited = savedTile.WasVisited;
            tile.resource = savedTile.Resource == null ? null : GameResource.FromSaveData(savedTile.Resource);
            tile.ContentNode.Visible = savedTile.WasVisited || (tile.collapsedMesh == "gate" && !layer.isGateOpen);
        }
    }
}