using System;
using System.Reflection;
using System.Collections;
using Server;
using Server.Gumps;
using Server.Network;
using Server.Commands;
using Server.Commands.Generic;

namespace Server.Commands
{
public class Batch : BaseCommand
{
private BaseCommandImplementor m_Scope;
private string m_Condition;
private ArrayList m_BatchCommands;

public BaseCommandImplementor Scope
{
get{ return m_Scope; }
set{ m_Scope = value; }
}

public string Condition
{
get{ return m_Condition; }
set{ m_Condition = value; }
}

public ArrayList BatchCommands
{
get{ return m_BatchCommands; }
}

public Batch()
{
Commands = new string[]{ "Batch" };
ListOptimized = true;

m_BatchCommands = new ArrayList();
m_Condition = "";
}

public override void ExecuteList( CommandEventArgs e, ArrayList list )
{
if ( list.Count == 0 )
{
LogFailure( "Nothing was found to use this command on." );
return;
}

try
{
BaseCommand[] commands = new BaseCommand[m_BatchCommands.Count];
CommandEventArgs[] eventArgs = new CommandEventArgs[m_BatchCommands.Count];

for ( int i = 0; i < m_BatchCommands.Count; ++i )
{
BatchCommand bc = (BatchCommand)m_BatchCommands[i];

string commandString, argString;
string[] args;

bc.GetDetails( out commandString, out argString, out args );

BaseCommand command = m_Scope.Commands[commandString];

commands[i] = command;
eventArgs[i] = new CommandEventArgs( e.Mobile, commandString, argString, args );

if ( command == null )
{
e.Mobile.SendMessage( "That is either an invalid command name or one that does not support this modifier: {0}.", commandString );
return;
}
else if ( e.Mobile.AccessLevel < command.AccessLevel )
{
e.Mobile.SendMessage( "You do not have access to that command: {0}.", commandString );
return;
}
else if ( !command.ValidateArgs( m_Scope, eventArgs[i] ) )
{
return;
}
}

for ( int i = 0; i < commands.Length; ++i )
{
BaseCommand command = commands[i];
BatchCommand bc = (BatchCommand)m_BatchCommands[i];

if ( list.Count > 20 )
CommandLogging.Enabled = false;

ArrayList usedList;

if ( Utility.InsensitiveCompare( bc.Object, "Current" ) == 0 )
{
usedList = list;
}
else
{
Hashtable propertyChains = new Hashtable();

usedList = new ArrayList( list.Count );

for ( int j = 0; j < list.Count; ++j )
{
object obj = list[j];

if ( obj == null )
continue;

Type type = obj.GetType();

PropertyInfo[] chain = (PropertyInfo[])propertyChains[type];

string failReason = "";

if ( chain == null && !propertyChains.Contains( type ) )
propertyChains[type] = chain = Properties.GetPropertyInfoChain( e.Mobile, type, bc.Object, PropertyAccess.Read, ref failReason );

if ( chain == null )
continue;

PropertyInfo endProp = Properties.GetPropertyInfo( ref obj, chain, ref failReason );

if ( endProp == null )
continue;

try
{
obj = endProp.GetValue( obj, null );

if ( obj != null )
usedList.Add( obj );
}
catch
{
}
}
}

command.ExecuteList( eventArgs[i], usedList );

if ( list.Count > 20 )
CommandLogging.Enabled = true;

command.Flush( e.Mobile, list.Count > 20 );
}
}
catch ( Exception ex )
{
e.Mobile.SendMessage( ex.Message );
}
}

public bool Run( Mobile from )
{
if ( m_Scope == null )
{
from.SendMessage( "You must select the batch command scope." );
return false;
}
else if ( m_Condition.Length > 0 && !m_Scope.SupportsConditionals )
{
from.SendMessage( "This command scope does not support conditionals." );
return false;
}
else if ( m_Condition.Length > 0 && !Utility.InsensitiveStartsWith( m_Condition, "where" ) )
{
from.SendMessage( "The condition field must start with \"where\"." );
return false;
}

string[] args = CommandSystem.Split( m_Condition );

m_Scope.Process( from, this, args );

return true;
}

public static void Initialize()
{
CommandSystem.Register( "Batch", AccessLevel.Counselor, new CommandEventHandler( Batch_OnCommand ) );
}

[Usage( "Batch" )]
[Description( "Allows multiple commands to be run at the same time." )]
public static void Batch_OnCommand( CommandEventArgs e )
{
Batch batch = new Batch();

e.Mobile.SendGump( new BatchGump( e.Mobile, batch ) );
}
}

public class BatchCommand
{
private string m_Command;
private string m_Object;

public string Command
{
get{ return m_Command; }
set{ m_Command = value; }
}

public string Object
{
get{ return m_Object; }
set{ m_Object = value; }
}

public void GetDetails( out string command, out string argString, out string[] args )
{
int indexOf = m_Command.IndexOf( ' ' );

if ( indexOf >= 0 )
{
argString = m_Command.Substring( indexOf + 1 );

command = m_Command.Substring( 0, indexOf );
args = CommandSystem.Split( argString );
}
else
{
argString = "";
command = m_Command.ToLower();
args = new string[0];
}
}

public BatchCommand( string command, string obj )
{
m_Command = command;
m_Object = obj;
}
}

public class BatchGump : BaseGridGump
{
private Mobile m_From;
private Batch m_Batch;

public BatchGump( Mobile from, Batch batch ) : base( 30, 30 )
{
m_From = from;
m_Batch = batch;

Render();
}

public void Render()
{
AddNewPage();

/* Header */
AddEntryHeader( 20 );
AddEntryHtml( 180, Center( "Batch Commands" ) );
AddEntryHeader( 20 );
AddNewLine();

AddEntryHeader( 9 );
AddEntryLabel( 191, "Run Batch" );
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, 0 ), ArrowRightWidth, ArrowRightHeight );
AddNewLine();

AddBlankLine();

/* Scope */
AddEntryHeader( 20 );
AddEntryHtml( 180, Center( "Scope" ) );
AddEntryHeader( 20 );
AddNewLine();

AddEntryHeader( 9 );
AddEntryLabel( 191, m_Batch.Scope == null ? "Select Scope" : m_Batch.Scope.Accessors[0] );
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, 1 ), ArrowRightWidth, ArrowRightHeight );
AddNewLine();

AddBlankLine();

/* Condition */
AddEntryHeader( 20 );
AddEntryHtml( 180, Center( "Condition" ) );
AddEntryHeader( 20 );
AddNewLine();

AddEntryHeader( 9 );
AddEntryText( 202, 0, m_Batch.Condition );
AddEntryHeader( 9 );
AddNewLine();

AddBlankLine();

/* Commands */
AddEntryHeader( 20 );
AddEntryHtml( 180, Center( "Commands" ) );
AddEntryHeader( 20 );

for ( int i = 0; i < m_Batch.BatchCommands.Count; ++i )
{
BatchCommand bc = (BatchCommand)m_Batch.BatchCommands[i];

AddNewLine();

AddImageTiled( CurrentX, CurrentY, 9, 2, 0x24A8 );
AddImageTiled( CurrentX, CurrentY + 2, 2, EntryHeight + OffsetSize + EntryHeight - 4, 0x24A8 );
AddImageTiled( CurrentX, CurrentY + EntryHeight + OffsetSize + EntryHeight - 2, 9, 2, 0x24A8 );
AddImageTiled( CurrentX + 3, CurrentY + 3, 6, EntryHeight + EntryHeight - 4 - OffsetSize, HeaderGumpID );

IncreaseX( 9 );
AddEntryText( 202, 1+(i*2), bc.Command );
AddEntryHeader( 9, 2 );

AddNewLine();

IncreaseX( 9 );
AddEntryText( 202, 2+(i*2), bc.Object );
}

AddNewLine();

AddEntryHeader( 9 );
AddEntryLabel( 191, "Add New Command" );
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, 2 ), ArrowRightWidth, ArrowRightHeight );

FinishPage();
}

public override void OnResponse( NetState sender, RelayInfo info )
{
int type, index;

if ( !SplitButtonID( info.ButtonID, 1, out type, out index ) )
return;

TextRelay entry = info.GetTextEntry( 0 );

if ( entry != null )
m_Batch.Condition = entry.Text;

for ( int i = m_Batch.BatchCommands.Count - 1; i >= 0; --i )
{
BatchCommand sc = (BatchCommand)m_Batch.BatchCommands[i];

entry = info.GetTextEntry( 1 + (i * 2) );

if ( entry != null )
sc.Command = entry.Text;

entry = info.GetTextEntry( 2 + (i * 2) );

if ( entry != null )
sc.Object = entry.Text;

if ( sc.Command.Length == 0 && sc.Object.Length == 0 )
m_Batch.BatchCommands.RemoveAt( i );
}

switch ( type )
{
case 0: // main
{
switch ( index )
{
case 0: // run
{
m_Batch.Run( m_From );
break;
}
case 1: // set scope
{
m_From.SendGump( new BatchScopeGump( m_From, m_Batch ) );
return;
}
case 2: // add command
{
m_Batch.BatchCommands.Add( new BatchCommand( "", "" ) );
break;
}
}

break;
}
}

m_From.SendGump( new BatchGump( m_From, m_Batch ) );
}
}

public class BatchScopeGump : BaseGridGump
{
private Mobile m_From;
private Batch m_Batch;

public BatchScopeGump( Mobile from, Batch batch ) : base( 30, 30 )
{
m_From = from;
m_Batch = batch;

Render();
}

public void Render()
{
AddNewPage();

/* Header */
AddEntryHeader( 20 );
AddEntryHtml( 140, Center( "Change Scope" ) );
AddEntryHeader( 20 );

/* Options */
for ( int i = 0; i < BaseCommandImplementor.Implementors.Count; ++i )
{
BaseCommandImplementor impl = BaseCommandImplementor.Implementors[i];

if ( m_From.AccessLevel < impl.AccessLevel )
continue;

AddNewLine();

AddEntryLabel( 20 + OffsetSize + 140, impl.Accessors[0] );
AddEntryButton( 20, ArrowRightID1, ArrowRightID2, GetButtonID( 1, 0, i ), ArrowRightWidth, ArrowRightHeight );
}

FinishPage();
}

public override void OnResponse( NetState sender, RelayInfo info )
{
int type, index;

if ( SplitButtonID( info.ButtonID, 1, out type, out index ) )
{
switch ( type )
{
case 0:
{
if ( index < BaseCommandImplementor.Implementors.Count )
{
BaseCommandImplementor impl = BaseCommandImplementor.Implementors[index];

if ( m_From.AccessLevel >= impl.AccessLevel )
m_Batch.Scope = impl;
}

break;
}
}
}

m_From.SendGump( new BatchGump( m_From, m_Batch ) );
}
}
}