using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;

namespace Server.Commands.Generic
{
public delegate BaseExtension ExtensionConstructor();

public sealed class ExtensionInfo
{
private static Dictionary<string, ExtensionInfo> m_Table = new Dictionary<string, ExtensionInfo>( StringComparer.InvariantCultureIgnoreCase );

public static Dictionary<string, ExtensionInfo> Table
{
get { return m_Table; }
}

public static void Register( ExtensionInfo ext )
{
m_Table[ext.m_Name] = ext;
}

private int m_Order;

private string m_Name;
private int m_Size;

private ExtensionConstructor m_Constructor;

public int Order
{
get { return m_Order; }
}

public string Name
{
get { return m_Name; }
}

public int Size
{
get { return m_Size; }
}

public bool IsFixedSize
{
get { return ( m_Size >= 0 ); }
}

public ExtensionConstructor Constructor
{
get { return m_Constructor; }
}

public ExtensionInfo( int order, string name, int size, ExtensionConstructor constructor )
{
m_Name = name;
m_Size = size;

m_Order = order;

m_Constructor = constructor;
}
}

public sealed class Extensions : List<BaseExtension>
{
public Extensions()
{
}

public bool IsValid( object obj )
{
for ( int i = 0; i < this.Count; ++i )
{
if ( !this[i].IsValid( obj ) )
return false;
}

return true;
}

public void Filter( ArrayList list )
{
for ( int i = 0; i < this.Count; ++i )
this[i].Filter( list );
}

public static Extensions Parse( Mobile from, ref string[] args )
{
Extensions parsed = new Extensions();

int size = args.Length;

Type baseType = null;

for ( int i = args.Length - 1; i >= 0; --i )
{
ExtensionInfo extInfo = null;

if ( !ExtensionInfo.Table.TryGetValue( args[i], out extInfo ) )
continue;

if ( extInfo.IsFixedSize && i != ( size - extInfo.Size - 1 ) )
throw new Exception( "Invalid extended argument count." );

BaseExtension ext = extInfo.Constructor();

ext.Parse( from, args, i + 1, size - i - 1 );

if ( ext is WhereExtension )
baseType = ( ext as WhereExtension ).Conditional.Type;

parsed.Add( ext );

size = i;
}

parsed.Sort( delegate( BaseExtension a, BaseExtension b )
{
return ( a.Order - b.Order );
} );

AssemblyEmitter emitter = null;

foreach ( BaseExtension update in parsed )
update.Optimize( from, baseType, ref emitter );

if ( size != args.Length )
{
string[] old = args;
args = new string[size];

for ( int i = 0; i < args.Length; ++i )
args[i] = old[i];
}

return parsed;
}
}

public abstract class BaseExtension
{
public abstract ExtensionInfo Info { get; }

public string Name
{
get { return Info.Name; }
}

public int Size
{
get { return Info.Size; }
}

public bool IsFixedSize
{
get { return Info.IsFixedSize; }
}

public int Order
{
get { return Info.Order; }
}

public virtual void Optimize( Mobile from, Type baseType, ref AssemblyEmitter assembly )
{
}

public virtual void Parse( Mobile from, string[] arguments, int offset, int size )
{
}

public virtual bool IsValid( object obj )
{
return true;
}

public virtual void Filter( ArrayList list )
{
}
}
}