extends Node

const SAVE_NAME = "playtest_2"

const SAVE_STORY_GAME_LOCATION = "user://stw_%s_save.tres" % SAVE_NAME
const SAVE_INFINTE_GAME_LOCATION = "user://stw_%s_infinite_save.tres" % SAVE_NAME
const SAVE_SETTINGS_LOCATION = "user://stw_settings.tres"

signal game_loaded

var game_mode_choosen := GameData.Mode.STORY

var game_data : GameData :
    get():
        if game_mode_choosen == GameData.Mode.STORY:
            return story_game_data
        elif game_mode_choosen == GameData.Mode.INFINITE:
            return infinite_game_data
        return null

var story_game_data : GameData
var infinite_game_data : GameData

var settings_data : SettingsData

var current_dialog_path : String

func load_story_game_data() -> GameData:
    story_game_data = null
    if ResourceLoader.exists(SAVE_STORY_GAME_LOCATION) and ResourceLoader.load(SAVE_STORY_GAME_LOCATION):
        story_game_data = ResourceLoader.load(SAVE_STORY_GAME_LOCATION).duplicate_deep()
        game_loaded.emit()

    return story_game_data

func load_infinite_game_data() -> GameData:
    infinite_game_data = null
    if ResourceLoader.exists(SAVE_INFINTE_GAME_LOCATION) and ResourceLoader.load(SAVE_INFINTE_GAME_LOCATION):
        infinite_game_data = ResourceLoader.load(SAVE_INFINTE_GAME_LOCATION).duplicate_deep()

    return infinite_game_data

func start_game_data():
    if game_mode_choosen == GameData.Mode.STORY:
        story_game_data = GameData.new(GameData.Mode.STORY)
        story_game_data.start_run()
    else:
        infinite_game_data = GameData.new(GameData.Mode.INFINITE)
        infinite_game_data.start_run()

    save_game_data()

func save_game_data():
    if game_mode_choosen == GameData.Mode.STORY:
        if story_game_data:
            ResourceSaver.save(story_game_data, SAVE_STORY_GAME_LOCATION)
    elif game_mode_choosen == GameData.Mode.INFINITE:
        if infinite_game_data:
            ResourceSaver.save(infinite_game_data, SAVE_INFINTE_GAME_LOCATION)

func load_settings_data() -> SettingsData:
    if ResourceLoader.exists(SAVE_SETTINGS_LOCATION):
        settings_data = ResourceLoader.load(SAVE_SETTINGS_LOCATION).duplicate_deep()
    else :
        settings_data = SettingsData.new()
        save_settings()

    return settings_data

func save_settings():
    if settings_data:
        ResourceSaver.save(settings_data, SAVE_SETTINGS_LOCATION)

func _init():
    load_story_game_data()
    load_infinite_game_data()
    load_settings_data()
    update_language_settings()
    update_video_settings()
    settings_data.language_changed.connect(_on_settings_language_changed)
    settings_data.video_changed.connect(_on_settings_video_changed)
    settings_data.sound_changed.connect(_on_settings_sound_changed)

func _ready():
    Dialogic.timeline_started.connect(_on_timeline_started)
    Dialogic.timeline_ended.connect(_on_timeline_ended)

func _on_settings_video_changed(s : SettingsData):
    update_video_settings(s)

func _on_settings_language_changed(s : SettingsData):
    update_language_settings(s)

func _on_settings_sound_changed(s : SettingsData):
    AudioServer.set_bus_volume_db(SettingsData.MUSIC_BUS_ID, linear_to_db(s.music_volume))
    AudioServer.set_bus_volume_db(SettingsData.SFX_BUS_ID, linear_to_db(s.sfx_volume))
    AudioServer.set_bus_volume_db(SettingsData.AMBIANCE_BUS_ID, linear_to_db(s.ambiance_volume))

func _on_timeline_started():
    current_dialog_path = Dialogic.current_timeline.resource_path

func _on_timeline_ended():
    if not current_dialog_path in game_data.dialogs_done:
        game_data.dialogs_done.append(current_dialog_path)
        save_game_data()

func update_language_settings(s : SettingsData = settings_data):
    TranslationServer.set_locale(s.language)

func update_video_settings(s : SettingsData = settings_data):
    DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN if s.full_screen else DisplayServer.WINDOW_MODE_WINDOWED)
    if not is_node_ready():
        await ready
    get_tree().root.content_scale_factor = s.ui_size
    

func update_inputs(s : SettingsData = settings_data):
    for i in range(len(s.input_remapped)):
        InputMap.action_erase_events(s.action_remapped[i])
        InputMap.action_add_event(s.action_remapped[i], s.input_remapped[i])
    
func has_unlocked_infinite_mode():
    return true