# File: medit.rb
# Author: Craig Smith
# This source code copyright (C) 2009 Craig Smith
# All rights reserved.
#
# Released under the terms of the GNU Public License
# See COPYING file for additional information.
#


require 'olc/oedit'

# Mobile Editor OLC Object
class Medit < Oedit
   logger 'DEBUG'
   attr_accessor :stats, :default_stats

   def initialize(id, oid, args=nil)
	self.title = "Mobile Editor" if not title
	if not obj and not oid
		self.obj = Mobile.new(args, id, nil) if not oid
		self.newobj = true
	end
	super(id,oid,args)
	self.default_attr = [ "fixed", "aggressive", "night_vision", "see_invisible", "invisible", "infected", "guard", "infect_guard" , "wimpy", "scavenger"]
	self.default_stats = {
		"strength" => [ 16,17,18,19,20 ],
		 "endurance" => [ 16,17,18,19,20 ],
		 "intel" => [ 16,17,18,19,20 ], 
		 "maxhp" => [ 50, 75, 100, 125, 150, 175, 200, 225, 250, 275, 300 ],
		 "maxmp" => [ 10, 20, 30, 40, 50 ], 
		 "exp" => [1, 15, 25, 35, 50, 75, 100, 125, 150, 200 ],
		 "level" => [1,2,3,4,5,6,7,8,9,10],
		 "cash" => [0,1,5,10,20,30,45,65,80,90,100 ],
		 "gender" => ["male","female","it" ]
		}
	self.default_hash = {
		"damagetype" => ["melee", "biting","clawing"]
	}
	@default_skills = { "bash" => [ 1,2,3,4,5,6,7,8,9,10 ] }
	@default_races = [ "human", "quad_tail" ]
	@cur_key = ""
	@current_stats = {}
   end   

   # Checks if the object is valid
   def is_valid?(obj)
	return true if obj.kind_of? Mobile
	false
   end

   # setup main menu
   def setup_main(m=nil)
	self.menu = olc_basemenu(title, self, :setup_main)
	menu.add_std_option(nil,"Name",obj.name,self,:set_name)
	menu.add_text_option(nil,"Aliases",self,:setup_aliases, obj.aliases)
	menu.add_std_option(nil,"Race",obj.race,self,:set_race_menu)
	menu.add_editor_option(nil,"Description",obj.desc,self,:set_desc)
	menu.add_text_option(nil,"Attributes",self,:setup_attr_menu,obj.attributes)
	menu.add_text_option(nil,"Attr Values",self,:setup_attr_val_menu,obj.val)
	menu.add_text_option(nil,"Skills",self,:setup_skill_menu,obj.skills)
	menu.add_text_option(nil,"General Stats", self, :setup_stats_menu, nil)
   end

   def setup_attr_val_menu(m=nil)
        smenu = olc_basemenu("Attribute Values", self, :setup_attr_val_menu, m)
        smenu.default_hash = default_hash.dup
        smenu.add_hash_numbered_options(obj.val, self, :pick_val)
        smenu.add_text_option("D#","Delete Attr Value #", self, :del_val)
        smenu.add_std_option(nil,"Add New Attribute Value",nil,self,:add_val)
        submenu(smenu, m)
   end

   # Skill menu
   def setup_skill_menu(m=nil)
        smenu = olc_basemenu("Skills", self, :setup_skill_menu, m)
        smenu.default_hash = @default_skills.dup
        smenu.add_hash_numbered_options(obj.skills, self, :pick_skill)
        smenu.add_text_option("D#","Delete Skill #", self, :del_skill)
        smenu.add_std_option(nil,"Add New Skill",nil,self,:add_skill_val)
        submenu(smenu, m)
   end

   # Refresh the current stats
   def refresh_stats
	@current_stats.clear
	default_stats.each_key do |key|
		val = obj.get_stat(key)
		case val
		when String, Symbol
			@current_stats[key] = obj.get_stat(key) if val.size > 0
		when Fixnum
			@current_stats[key] = obj.get_stat(key) if val > 0
		end
	end
   end

   # Stats Menu
   def setup_stats_menu(m=nil)
	smenu = olc_basemenu("General Stats", self, :setup_stats_menu, m)
	smenu.default_hash = default_stats.dup
	refresh_stats
	smenu.add_hash_numbered_options(@current_stats, self, :pick_stat)
	smenu.add_text_option("D#", "Delete Stat #", self, :del_stat)
	smenu.add_std_option(nil, "Add Stat value", nil, self, :add_stat)
	submenu(smenu, m)
   end

   def pick_skill(m)
	hash_keys = menu.get_hash_keys
        if m=~/(\d+)/
                idx = $1.to_i
                if idx > 0 and idx <= hash_keys.size
                        @cur_key = hash_keys[idx-1]
                        smenu = olc_basemenu("Skill [#{@cur_key}] - Set Value", self, :pick_skill,m)
                        current = ""
                        if obj.skills.has_key? @cur_key
                                current = obj.skills[@cur_key]
                        end
                        if @default_skills.has_key? @cur_key
                                if @default_skills[@cur_key] == nil
                                        smenu.add_std_option(nil,"Enter a value",0,self,:set_default_skill)
                                else
                                        smenu.add_numbered_option(@default_skills[@cur_key], self, :pick_default_skill)
                                end
                        end
                        smenu.add_std_option(nil,"Set new value",current, self, :set_new_skill)
                        submenu(smenu,m)
                end
        else
                smenu = olc_basemenu("Skills - Set Value", self, :pick_skill,m)
                smenu.add_numbered_option(@default_skills[@cur_key], self, :pick_default_skill)
                smenu.add_std_option(nil,"Set new value",obj.skills[@cur_key], self, :set_new_skill)
                submenu(smenu,m)
        end
   end

   def del_skill(m)
	hash_keys = menu.get_hash_keys
        if m=~/(\d+)/
                idx = $1.to_i
                if idx > 0 and idx <= hash_keys.size
                        if obj.has_skill? hash_keys[idx-1]
				obj.set_skill_level(hash_keys[idx-1], 0)
                        end
                end
        end
	menu.active_hash = obj.skills
        show_menu
   end

   def add_skill_val(m)
        if not obj.has_skill? m
                obj.add_skill(m)
                show_menu
                obj.skills
        end
   end

   def set_new_skill(m)
        m.strip!
        if m=~/^\d+$/
		obj.set_skill_level(@cur_key, m.to_i)
        end
	menu.active_hash = obj.skills
        show_menu
        m
   end

   def pick_default_skill(m)
       skills = @default_skills[@cur_key]
        if m=~/(\d+)/
                idx = $1.to_i
                if idx > 0 and idx <= skills.size
			obj.set_skill_value(@cur_key, skills[idx-1])
                end
        end
	menu.active_hash = obj.skills
        quit_menu
   end

   def set_default_skill(m)
        if m=~/^\d+$/
		obj.set_skill_val(@cur_key, m.to_i)
        end
	menu.active_hash = obj.skills
        show_menu
        m
   end

   def pick_stat(m)
	hash_keys = menu.get_hash_keys
        if m=~/(\d+)/
                idx = $1.to_i
                if idx > 0 and idx <= hash_keys.size
                        @cur_key = hash_keys[idx-1]
                        smenu = olc_basemenu("Stat [#{@cur_key}] - Set Value", self, :pick_stat,m)
                        current = ""
                        if obj.stats.has_key? @cur_key.to_sym
                                current = obj.stats[@cur_key.to_sym]
                        end
                        if default_stats.has_key? @cur_key
                                if default_stats[@cur_key] == nil
                                        smenu.add_std_option(nil,"Enter a value",0,self,:set_default_stat)
                                else
                                        smenu.add_numbered_option(default_stats[@cur_key], self, :pick_default_stat)
                                end
                        end
                        smenu.add_std_option(nil,"Set new value",current, self, :set_new_stat)
                        submenu(smenu,m)
                end
        else
                smenu = olc_basemenu("Stats - Set Value", self, :pick_stat,m)
                smenu.add_numbered_option(default_stats[@cur_key], self, :pick_default_stats)
                smenu.add_std_option(nil,"Set new value",obj.stats[@cur_key.to_sym], self, :set_new_stat)
                submenu(smenu,m)
        end
   end

   def del_stat(m)
	hash_keys = menu.get_hash_keys
        if m=~/(\d+)/
                idx = $1.to_i
                if idx > 0 and idx <= hash_keys.size
                        if obj.stats.has_key? hash_keys[idx-1].to_sym
				obj.set_stat(hash_keys[idx-1], 0)
                        end
                end
        end
	refresh_stats
	menu.active_hash = @current_stats
        show_menu
   end

   def add_stat_val(m)
        if not obj.get_stat?(m) > 0
                obj.set_stat(m, 0)
		menu.active_hash = obj.stats
                show_menu
                obj.stats
        end
   end

   def set_new_stat(m)
        m.strip!
        if m=~/^\d+$/
		obj.set_stat(@cur_key, m.to_i)
        end
	refresh_stats
	menu.active_hash = @current_stats
        show_menu
        m
   end

   def pick_default_stat(m)
       stats = default_stats[@cur_key]
        if m=~/(\d+)/
                idx = $1.to_i
                if idx > 0 and idx <= stats.size
			obj.set_stat(@cur_key, stats[idx-1])
                end
        end
	refresh_stats
	menu.active_hash = @current_stats
        quit_menu
   end

   def set_default_stat(m)
        if m=~/^\d+$/
		obj.set_stat(@cur_key, m.to_i)
        end
	refresh_stats
	menu.active_hash =  @current_stats
        show_menu
        m
   end

   def pick_val(m=nil)
	hash_keys = menu.get_hash_keys
	if m=~/(\d+)/
		idx = $1.to_i
		if idx > 0 and idx <= hash_keys.size
			@cur_key = hash_keys[idx-1]
			smenu = olc_basemenu("Attribute Values [#{@cur_key}] - Set Value", self, :pick_val,m)
			current = ""
			if obj.val.has_key? @cur_key
				current = obj.val[@cur_key]
			end
			if default_hash.has_key? @cur_key
				if default_hash[@cur_key] == nil
					smenu.add_std_option(nil,"Enter a value",0,self,:set_default_val)
				else
					smenu.add_numbered_option(default_hash[@cur_key], self, :pick_default_val)
				end
			end
			smenu.add_std_option(nil,"Set new value",current, self, :set_new_val)
			submenu(smenu,m)
		end
	else
		smenu = olc_basemenu("Attribute Values - Set Value", self, :pick_val,m)
		smenu.add_numbered_option(default_hash[@cur_key], self, :pick_default_val)
		smenu.add_std_option(nil,"Set new value",obj.val[@cur_key], self, :set_new_val)
		submenu(smenu,m)
	end
   end

   def pick_default_val(m)
	vals = default_hash[@cur_key]
	if m=~/(\d+)/
		idx = $1.to_i
		if idx > 0 and idx <= vals.size
			obj.add_val(@cur_key, vals[idx-1])
		end
	end
	menu.active_hash = obj.val
	quit_menu
   end

   def set_default_val(m)
	if m=~/^\d+$/
		obj.add_val(@cur_key, m.to_i)
	else
		obj.add_val(@cur_key, m)
	end
	menu.active_hash = obj.val
	show_menu
	m
   end

   def set_new_val(m)
	m.strip!
	if m=~/^\d+$/
		obj.add_val(@cur_key, m.to_i)
	else
		obj.add_val(@cur_key, m)
	end
	menu.active_hash = obj.val
	show_menu
	m
   end

   def del_val(m)
	hash_keys = menu.get_hash_keys
	if m=~/(\d+)/
		idx = $1.to_i
		if idx > 0 and idx <= hash_keys.size
			if obj.has_val? hash_keys[idx-1]
				obj.del_val(hash_keys[idx-1])
			end
		end
	end
	menu.active_hash = obj.val
	show_menu
	obj.val
   end

   def add_val(m)
	if not obj.has_val? m
		obj.add_val(m,"")
		menu.active_hash = obj.val
		show_menu
		obj.val
	end
   end

   def set_race_menu(m=nil)
        smenu = olc_basemenu("Race", self, :set_race_menu, m)
        smenu.add_numbered_option(@default_races, self, :pick_race)
        submenu(smenu, m)
	show_menu
   end

  def pick_race(m)
	idx = m.to_i
	if idx > 0 and idx <= @default_races.size
		obj.race = @default_races[idx-1].to_sym
	end
	obj.race
  end

end