#region Arthea License

/***********************************************************************
*  Arthea MUD by R. Jennings (2007)      http://arthea.googlecode.com/ *
*  By using this code you comply with the Artistic and GPLv2 Licenses. *
***********************************************************************/

#endregion

using System;
using System.Reflection;
using Arthea.Continents.Areas.Characters;
using Arthea.Continents.Areas.Items;
using Arthea.Continents.Areas.Rooms;
using Arthea.Environment;
using Arthea.Interfaces;

namespace Arthea.Scripts
{
    /// <summary>
    /// Implementation of a item script.
    /// </summary>
    public class ItemScript : Script
    {
        #region [rgn] Constructors (2)

        /// <summary>
        /// Initializes a new instance of the <see cref="ItemScript"/> class.
        /// </summary>
        /// <param name="code">The code.</param>
        /// <param name="trigger">The trigger.</param>
        public ItemScript(ScriptCode code, string trigger)
            : base(code, trigger)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ItemScript"/> class.
        /// </summary>
        public ItemScript()
        {
        }

        #endregion [rgn]

        #region [rgn] Methods (6)

        // [rgn] Public Methods (5)

        /// <summary>
        /// Loads a character.
        /// </summary>
        /// <param name="from">Where the script is coming from.</param>
        /// <param name="argument">The argument.</param>
        public void CLoad(Item from, String argument)
        {
            uint id;
            CharIndex index;

            if (!uint.TryParse(argument, out id) || (index = Lists.CharIndexes[id]) == null)
            {
                Log.Bug("CharScript.CLoad: Invalid argument (script {0})", Code.Id);
                return;
            }

            Character vict = new Character(index);

            vict.Attach();

            from.Room.Characters.Add(vict);
        }

        /// <summary>
        /// Echoes a message to an items room.
        /// </summary>
        /// <param name="from">Where the script came from.</param>
        /// <param name="argument">The argument.</param>
        public void Echo(Item from, String argument)
        {
            if (from.CarriedBy != null)
                from.CarriedBy.Act(null, null, Act.ToRoom, argument);
            else if (from.Room != null)
                from.Room.WriteLine(argument);
            else
                Log.Bug("ItemScript.Echo: No room! (script {0})", Code.Id);
        }

        /// <summary>
        /// Echoes around a character.
        /// </summary>
        /// <param name="from">The character.</param>
        /// <param name="argument">The argument.</param>
        public void EchoAround(Item from, String argument)
        {
            Character victim = from.Room.Characters.FindName(argument);

            if (victim == null)
                return;

            Room room = (from.Room ?? (from.CarriedBy != null ? from.CarriedBy.Room : null));

            if (room == null)
            {
                Log.Bug("ItemScript.EchoAround: No Room! (script {0})", Code.Id);
                return;
            }

            foreach (Character ch in room.Characters)
            {
                if (ch != victim)
                    ch.WriteLine(argument);
            }
        }

        /// <summary>
        /// Echoes at a victim.
        /// </summary>
        /// <param name="from">The character issuing the script.</param>
        /// <param name="argument">The argument.</param>
        public void EchoAt(Item from, String argument)
        {
            Character victim = from.Room.Characters.FindName(argument);

            if (victim == null)
                return;

            victim.WriteLine(argument);
        }

        /// <summary>
        /// Loads an from to the room
        /// </summary>
        /// <param name="from">The from.</param>
        /// <param name="argument">The argument.</param>
        public void ILoad(Item from, String argument)
        {
            uint id;
            ItemIndex index;

            if (!uint.TryParse(argument, out id) || (index = Lists.ItemIndexes[id]) == null)
            {
                Log.Bug("RoomScript.ILoad: Invalid argument (script {0})", Code.Id);
                return;
            }

            Item item = new Item(index);

            item.Attach();

            from.Room.Items.Add(item);
        }

        // [rgn] Protected Methods (1)

        /// <summary>
        /// Interprets a script command.
        /// </summary>
        /// <param name="from">The object with the script.</param>
        /// <param name="cmd">The command (method name).</param>
        /// <param name="argument">The argument.</param>
        /// <returns>true if a command was interpreted</returns>
        protected override bool InterpretCommand(Scriptable from, String cmd, String argument)
        {
            MethodInfo method = GetType().GetMethod(cmd.Capitalize(false),
                                                    BindingFlags.Public | BindingFlags.Instance |
                                                    BindingFlags.IgnoreCase, null,
                                                    new Type[] {typeof (Item), typeof (String)}, null);

            if (method == null)
                return false;

            method.Invoke(this, new object[] {from, argument});
            return true;
        }

        #endregion [rgn]
    }
}