#==============================================================================
# ** Save/Load
#------------------------------------------------------------------------------
#  Handles saving, loading, and suspending
#==============================================================================

class Window_SaveFile
  #--------------------------------------------------------------------------
  # * Object Initialization
  #     file_index : save file index (0-3)
  #     filename   : file name
  #--------------------------------------------------------------------------
  def initialize(file_index, filename)
    super(0, 32 + file_index % 4 * 48, 640, 104)
    self.contents = Bitmap.new(width - 32, height - 32)
    @file_index = file_index
    @filename = filename
    @time_stamp = Time.at(0)
    @file_exist = FileTest.exist?(@filename)
    if @file_exist
      file = File.open(@filename, "r")
      @time_stamp = file.mtime
      @characters = Marshal.load(file)
      @frame_count = Marshal.load(file)
      @game_system = Marshal.load(file)
      @game_switches = Marshal.load(file)
      @game_variables = Marshal.load(file)
      @total_sec = @frame_count / Graphics.frame_rate
      file.close
    end
    refresh
    @selected = false
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    # Draw file number
    self.contents.font.color = normal_color
    name = "File#{@file_index + 1}"
    self.contents.draw_text(4, 0, 600, 32, name)
    @name_width = contents.text_size(name).width
    # If save file exists
    if @file_exist
      # Draw character
      #for i in 0...@characters.size
      #  bitmap = RPG::Cache.character('Map' + @characters[i][0],
      #      @characters[i][1])
      #  cw = bitmap.rect.width / 3
      #  ch = bitmap.rect.height / 3
      #  src_rect = Rect.new(0, 0, cw, ch)
      #  x = 300 - @characters.size * 32 + i * 64 - cw / 2
      #  self.contents.blt(x, 68 - ch, bitmap, src_rect)
      #end
      # Draw play time
      hour = @total_sec / 60 / 60
      min = @total_sec / 60 % 60
      sec = @total_sec % 60
      time_string = sprintf("%02d:%02d:%02d", hour, min, sec)
      self.contents.font.color = normal_color
      self.contents.draw_text(4, 8, 600, 32, time_string, 2)
      # Draw timestamp
      self.contents.font.color = normal_color
      time_string = @time_stamp.strftime("%Y/%m/%d %H:%M")
      self.contents.draw_text(4, 40, 600, 32, time_string, 2)
    end
  end
end



#==============================================================================
# ** Window_MenuStatus
#------------------------------------------------------------------------------
#  This window displays party member status on the menu screen.
#==============================================================================

class Window_MenuStatus
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = $game_party.actors.size
    for i in 0...$game_party.actors.size
      x = 64
      y = i * 116
      actor = $game_party.actors[i]
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x + 144, y)
      draw_actor_level(actor, x, y + 32)
      draw_actor_state(actor, x + 90, y + 32)
      draw_actor_exp(actor, x, y + 64)
      draw_actor_hp(actor, x + 236, y + 32)
      draw_actor_sp(actor, x + 236, y + 64)
    end
  end
end



#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  This is a superclass for the save screen and load screen.
#==============================================================================

class Scene_File
  #--------------------------------------------------------------------------
  # * Main Processing : Window Initialization
  #--------------------------------------------------------------------------
  def main_window
    super
    # Make help window
    @help_window = Window_Help.new
    @help_window.set_text(@help_text)
    # Make save file window
    @savefile_windows = []
    for i in 0..3
      @savefile_windows.push(Window_SaveFile.new(i, make_filename(i)))
    end
    @savefile_windows[@file_index].selected = true
  end
end



class Scene_Save
  alias_method :bwd_fe_scnsave_write_data, :write_data
  def write_data(file)
    begin
      bwd_fe_scnsave_write_data(file)
    rescue
      $game_map.whoops
    end
    Marshal.dump($data_actors, file)
    Marshal.dump($game_recolor, file)
  end
end

class Scene_Load
  #--------------------------------------------------------------------------
  # * Read Data
  #--------------------------------------------------------------------------
  alias_method :bwd_fe_scnload_read_data, :read_data
  def read_data(file)
    bwd_fe_scnload_read_data(file)
    $data_actors        = Marshal.load(file)
    $game_recolor       = Marshal.load(file)
  end
end

class SDK::Scene_Base
  attr_reader   :suspend_calling
  #--------------------------------------------------------------------------
  # * Suspend Flag Set
  #--------------------------------------------------------------------------
  def suspend
    @suspend_calling = true
  end
  #--------------------------------------------------------------------------
  # * Suspend
  #--------------------------------------------------------------------------
  def suspend_data
    # Write save data
    file = File.open('Suspend.rxdata', "wb")
    suspend_write_characters(file)
    suspend_write_frame(file)
    suspend_write_setup(file)
    suspend_write_data(file)
    file.close
  end
  #--------------------------------------------------------------------------
  # * Make Character Data
  #--------------------------------------------------------------------------
  def suspend_write_characters(file)
    # Make character data for drawing save file
    characters = []
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      characters.push([actor.character_name, actor.character_hue])
    end
    # Write character data for drawing save file
    Marshal.dump(characters, file)
  end
  #--------------------------------------------------------------------------
  # * Write Frame Count
  #--------------------------------------------------------------------------
  def suspend_write_frame(file)
    # Wrire frame count for measuring play time
    Marshal.dump(Graphics.frame_count, file)
  end
  #--------------------------------------------------------------------------
  # * Write Setup
  #--------------------------------------------------------------------------
  def suspend_write_setup(file)
    # Increase save count by 1
    $game_system.save_count += 1
    # Save magic number
    # (A random value will be written each time saving with editor)
    $game_system.magic_number = $data_system.magic_number
  end
  #--------------------------------------------------------------------------
  # * Write Data
  #--------------------------------------------------------------------------
  def suspend_write_data(file)
    # Write each type of game object
    Marshal.dump($game_system, file)
    Marshal.dump($game_switches, file)
    Marshal.dump($game_variables, file)
    Marshal.dump($game_self_switches, file)
    Marshal.dump($game_screen, file)
    Marshal.dump($game_actors, file)
    Marshal.dump($game_party, file)
    Marshal.dump($game_troop, file)
    #$game_map.sprite_print #Yeti
    Marshal.dump($game_map, file)
    Marshal.dump($game_player, file)
    Marshal.dump($data_actors, file)
    Marshal.dump($game_recolor, file)
    Marshal.dump(Event_Spawner.saved_events, file)
  end
  #--------------------------------------------------------------------------
  # * Read Save Data
  #     file : file object for reading (opened)
  #--------------------------------------------------------------------------
  def load_suspend
    $game_temp = Game_Temp.new
    # Read save data
    file = File.open('Suspend.rxdata', "rb")
    suspend_read_characters(file)
    suspend_read_frame(file)
    data = suspend_read_data(file)
    if !suspend_read_edit
      # Play buzzer SE
      $game_system.se_play($data_system.buzzer_se)
      file.close
      return
    else
      set_suspend_data(data)
      # Play decision SE
      $game_system.se_play($data_system.decision_se)
    end
    suspend_read_refresh
    file.close
    # Restore BGM and BGS
    unless $game_system.playing_bgm.nil?
      $game_system.playing_bgm.position = 0
    end
    unless $game_system.in_arena
      $game_system.bgm_play($game_system.playing_bgm)
      $game_system.bgs_play($game_system.playing_bgs)
    end
    $game_map.wait_time = 10
    # Update map (run parallel process event)
    $game_map.update
    $game_map.update_map_animation
    $game_map.highlight_test
    # Switch to map screen
    $scene = $game_system.in_arena ? Scene_Arena.new(
        $game_system.arena_distance) : Scene_Map.new
  end
  #--------------------------------------------------------------------------
  # * Read Character Data
  #--------------------------------------------------------------------------
  def suspend_read_characters(file)
    # Read character data for drawing save file
    characters = Marshal.load(file)
  end
  #--------------------------------------------------------------------------
  # * Read Frame Count
  #--------------------------------------------------------------------------
  def suspend_read_frame(file)
    # Read frame count for measuring play time
    Graphics.frame_count = Marshal.load(file)
  end
  #--------------------------------------------------------------------------
  # * Read Data
  #--------------------------------------------------------------------------
  def suspend_read_data(file)
    data = []
    13.times do
      data.push(Marshal.load(file))
    end
    # Read each type of game object
    #$game_system        = Marshal.load(file)
    #$game_switches      = Marshal.load(file)
    #$game_variables     = Marshal.load(file)
    #$game_self_switches = Marshal.load(file)
    #$game_screen        = Marshal.load(file)
    #$game_actors        = Marshal.load(file)
    #$game_party         = Marshal.load(file)
    #$game_troop         = Marshal.load(file)
    #$game_map           = Marshal.load(file)
    #$game_player        = Marshal.load(file)
    #$data_actors        = Marshal.load(file)
    #$game_recolor       = Marshal.load(file)
    #Event_Spawner.saved_events = Marshal.load(file)
    return data
  end
  
  def set_suspend_data(data)
    $game_system        = data[0]
    $game_switches      = data[1]
    $game_variables     = data[2]
    $game_self_switches = data[3]
    $game_screen        = data[4]
    $game_actors        = data[5]
    $game_party         = data[6]
    $game_troop         = data[7]
    $game_map           = data[8]
    $game_player        = data[9]
    $data_actors        = data[10]
    $game_recolor       = data[11]
    Event_Spawner.saved_events = data[12]
  end
  #--------------------------------------------------------------------------
  # * Read Edit
  #--------------------------------------------------------------------------
  def suspend_read_edit
    # If magic number is different from when saving
    # (if editing was added with editor)
    if $game_system.magic_number != $data_system.magic_number
      return false unless $DEBUG # and Input.press?(Input::Y)
      print 'Save not for this version, continuing anyway'
    end
    return true
  end
  #--------------------------------------------------------------------------
  # * Refresh Game Party
  #--------------------------------------------------------------------------
  def suspend_read_refresh
    # Refresh party members
    $game_party.refresh
  end
end