using System;
using System.IO;
using System.Xml;
using System.Collections;
using System.Reflection;
using Server;
using Server.Items;

namespace Server.Commands
{
public class Categorization
{
private static CategoryEntry m_RootItems, m_RootMobiles;

public static CategoryEntry Items
{
get
{
if ( m_RootItems == null )
Load();

return m_RootItems;
}
}

public static CategoryEntry Mobiles
{
get
{
if ( m_RootMobiles == null )
Load();

return m_RootMobiles;
}
}

public static void Initialize()
{
CommandSystem.Register( "RebuildCategorization", AccessLevel.Administrator, new CommandEventHandler( RebuildCategorization_OnCommand ) );
}

[Usage( "RebuildCategorization" )]
[Description( "Rebuilds the categorization data file used by the Add command." )]
public static void RebuildCategorization_OnCommand( CommandEventArgs e )
{
CategoryEntry root = new CategoryEntry( null, "Add Menu", new CategoryEntry[]{ Items, Mobiles } );

Export( root, "Data/objects.xml", "Objects" );

e.Mobile.SendMessage( "Categorization menu rebuilt." );
}

public static void RecurseFindCategories( CategoryEntry ce, ArrayList list )
{
list.Add( ce );

for ( int i = 0; i < ce.SubCategories.Length; ++i )
RecurseFindCategories( ce.SubCategories[i], list );
}

public static void Export( CategoryEntry ce, string fileName, string title )
{
XmlTextWriter xml = new XmlTextWriter( fileName, System.Text.Encoding.UTF8 );

xml.Indentation = 1;
xml.IndentChar = '\t';
xml.Formatting = Formatting.Indented;

xml.WriteStartDocument( true );

RecurseExport( xml, ce );

xml.Flush();
xml.Close();
}

public static void RecurseExport( XmlTextWriter xml, CategoryEntry ce )
{
xml.WriteStartElement( "category" );

xml.WriteAttributeString( "title", ce.Title );

ArrayList subCats = new ArrayList( ce.SubCategories );

subCats.Sort( new CategorySorter() );

for ( int i = 0; i < subCats.Count; ++i )
RecurseExport( xml, (CategoryEntry)subCats[i] );

ce.Matched.Sort( new CategorySorter() );

for ( int i = 0; i < ce.Matched.Count; ++i )
{
CategoryTypeEntry cte = (CategoryTypeEntry)ce.Matched[i];

xml.WriteStartElement( "object" );

xml.WriteAttributeString( "type", cte.Type.ToString() );

object obj = cte.Object;

if ( obj is Item )
{
Item item = (Item)obj;

int itemID = item.ItemID;

if ( item is BaseAddon && ((BaseAddon)item).Components.Count == 1 )
itemID = ((AddonComponent)(((BaseAddon)item).Components[0])).ItemID;

if ( itemID >= 0x4000 )
itemID = 1;

xml.WriteAttributeString( "gfx", XmlConvert.ToString( itemID ) );

int hue = item.Hue & 0x7FFF;

if ( (hue & 0x4000) != 0 )
hue = 0;

if ( hue != 0 )
xml.WriteAttributeString( "hue", XmlConvert.ToString( hue ) );

item.Delete();
}
else if ( obj is Mobile )
{
Mobile mob = (Mobile)obj;

int itemID = ShrinkTable.Lookup( mob, 1 );

xml.WriteAttributeString( "gfx", XmlConvert.ToString( itemID ) );

int hue = mob.Hue & 0x7FFF;

if ( (hue & 0x4000) != 0 )
hue = 0;

if ( hue != 0 )
xml.WriteAttributeString( "hue", XmlConvert.ToString( hue ) );

mob.Delete();
}

xml.WriteEndElement();
}

xml.WriteEndElement();
}

public static void Load()
{
ArrayList types = new ArrayList();

AddTypes( Core.Assembly, types );

for ( int i = 0; i < ScriptCompiler.Assemblies.Length; ++i )
AddTypes( ScriptCompiler.Assemblies[i], types );

m_RootItems = Load( types, "Data/items.cfg" );
m_RootMobiles = Load( types, "Data/mobiles.cfg" );
}

private static CategoryEntry Load( ArrayList types, string config )
{
CategoryLine[] lines = CategoryLine.Load( config );

if ( lines.Length > 0 )
{
int index = 0;
CategoryEntry root = new CategoryEntry( null, lines, ref index );

Fill( root, types );

return root;
}

return new CategoryEntry();
}

private static Type typeofItem = typeof( Item );
private static Type typeofMobile = typeof( Mobile );
private static Type typeofConstructable = typeof( ConstructableAttribute );

private static bool IsConstructable( Type type )
{
if ( !type.IsSubclassOf( typeofItem ) && !type.IsSubclassOf( typeofMobile ) )
return false;

ConstructorInfo ctor = type.GetConstructor( Type.EmptyTypes );

return ( ctor != null && ctor.IsDefined( typeofConstructable, false ) );
}

private static void AddTypes( Assembly asm, ArrayList types )
{
Type[] allTypes = asm.GetTypes();

for ( int i = 0; i < allTypes.Length; ++i )
{
Type type = allTypes[i];

if ( type.IsAbstract )
continue;

if ( IsConstructable( type ) )
types.Add( type );
}
}

private static void Fill( CategoryEntry root, ArrayList list )
{
for ( int i = 0; i < list.Count; ++i )
{
Type type = (Type)list[i];
CategoryEntry match = GetDeepestMatch( root, type );

if ( match == null )
continue;

try
{
match.Matched.Add( new CategoryTypeEntry( type ) );
}
catch
{
}
}
}

private static CategoryEntry GetDeepestMatch( CategoryEntry root, Type type )
{
if ( !root.IsMatch( type ) )
return null;

for ( int i = 0; i < root.SubCategories.Length; ++i )
{
CategoryEntry check = GetDeepestMatch( root.SubCategories[i], type );

if ( check != null )
return check;
}

return root;
}
}

public class CategorySorter : IComparer
{
public int Compare( object x, object y )
{
string a = null, b = null;

if ( x is CategoryEntry )
a = ((CategoryEntry)x).Title;
else if ( x is CategoryTypeEntry )
a = ((CategoryTypeEntry)x).Type.Name;

if ( y is CategoryEntry )
b = ((CategoryEntry)y).Title;
else if ( y is CategoryTypeEntry )
b = ((CategoryTypeEntry)y).Type.Name;

if ( a == null && b == null )
return 0;

if ( a == null )
return 1;

if ( b == null )
return -1;

return a.CompareTo( b );
}
}

public class CategoryTypeEntry
{
private Type m_Type;
private object m_Object;

public Type Type{ get{ return m_Type; } }
public object Object{ get{ return m_Object; } }

public CategoryTypeEntry( Type type )
{
m_Type = type;
m_Object = Activator.CreateInstance( type );
}
}

public class CategoryEntry
{
private string m_Title;
private Type[] m_Matches;
private CategoryEntry[] m_SubCategories;
private CategoryEntry m_Parent;
private ArrayList m_Matched;

public string Title{ get{ return m_Title; } }
public Type[] Matches{ get{ return m_Matches; } }
public CategoryEntry Parent{ get{ return m_Parent; } }
public CategoryEntry[] SubCategories{ get{ return m_SubCategories; } }
public ArrayList Matched{ get{ return m_Matched; } }

public CategoryEntry()
{
m_Title = "(empty)";
m_Matches = new Type[0];
m_SubCategories = new CategoryEntry[0];
m_Matched = new ArrayList();
}

public CategoryEntry( CategoryEntry parent, string title, CategoryEntry[] subCats )
{
m_Parent = parent;
m_Title = title;
m_SubCategories = subCats;
m_Matches = new Type[0];
m_Matched = new ArrayList();
}

public bool IsMatch( Type type )
{
bool isMatch = false;

for ( int i = 0; !isMatch && i < m_Matches.Length; ++i )
isMatch = ( type == m_Matches[i] || type.IsSubclassOf( m_Matches[i] ) );

return isMatch;
}

public CategoryEntry( CategoryEntry parent, CategoryLine[] lines, ref int index )
{
m_Parent = parent;

string text = lines[index].Text;

int start = text.IndexOf( '(' );

if ( start < 0 )
throw new FormatException( String.Format( "Input string not correctly formatted ('{0}')", text ) );

m_Title = text.Substring( 0, start ).Trim();

int end = text.IndexOf( ')', ++start );

if ( end < start )
throw new FormatException( String.Format( "Input string not correctly formatted ('{0}')", text ) );

text = text.Substring( start, end-start );
string[] split = text.Split( ';' );

ArrayList list = new ArrayList();

for ( int i = 0; i < split.Length; ++i )
{
Type type = ScriptCompiler.FindTypeByName( split[i].Trim() );

if ( type == null )
Console.WriteLine( "Match type not found ('{0}')", split[i].Trim() );
else
list.Add( type );
}

m_Matches = (Type[])list.ToArray( typeof( Type ) );
list.Clear();

int ourIndentation = lines[index].Indentation;

++index;

while ( index < lines.Length && lines[index].Indentation > ourIndentation )
list.Add( new CategoryEntry( this, lines, ref index ) );

m_SubCategories = (CategoryEntry[])list.ToArray( typeof( CategoryEntry ) );
list.Clear();

m_Matched = list;
}
}

public class CategoryLine
{
private int m_Indentation;
private string m_Text;

public int Indentation{ get{ return m_Indentation; } }
public string Text{ get{ return m_Text; } }

public CategoryLine( string input )
{
int index;

for ( index = 0; index < input.Length; ++index )
{
if ( Char.IsLetter( input, index ) )
break;
}

if ( index >= input.Length )
throw new FormatException( String.Format( "Input string not correctly formatted ('{0}')", input ) );

m_Indentation = index;
m_Text = input.Substring( index );
}

public static CategoryLine[] Load( string path )
{
ArrayList list = new ArrayList();

if ( File.Exists( path ) )
{
using ( StreamReader ip = new StreamReader( path ) )
{
string line;

while ( (line = ip.ReadLine()) != null )
list.Add( new CategoryLine( line ) );
}
}

return (CategoryLine[])list.ToArray( typeof( CategoryLine ) );
}
}
}