/*
**               j###t  ########## ####   ####
**              j###t   ########## ####   ####
**             j###T               "###L J###"
**          ######P'    ##########  #########
**          ######k,    ##########   T######T
**          ####~###L   ####
**          #### q###L  ##########   .#####
**          ####  \###L ##########   #####"
*/

package key.commands;

import key.*;
import key.util.Trie;
import key.commands.clan.*;

import java.util.StringTokenizer;
import java.io.IOException;

import java.util.Enumeration;

/**
  *  An abstract superclass containing the common functionality
  *  between the creating functions.  (They're all pretty similar)
 */
public abstract class Create extends Command
{
	private static final long serialVersionUID = 2823156582231052536L;
	public Create()
	{
		setKey( "create" );
		usage = "";
	}
	
	public void add( InteractiveConnection ic, Atom created, Container place, String successFeedback ) throws IOException
	{
		try
		{
			place.add( created );
			ic.sendFeedback( successFeedback );
		}
		catch( BadKeyException e )
		{
			ic.sendError( "'" + created.getName() + "' should contain only alphabetic characters" );
		}
		catch( NonUniqueKeyException e )
		{
			ic.sendError( "There is already something of that name here" );
		}
		catch( TypeMismatchException e )
		{
			ic.sendError( "I don't quite know how to break this to you, so I'm just going to say it.  It seems that " + place.getName() + " isn't really meant to hold " + Type.typeOf( created ).getName() + "." );
		}
		catch( AccessViolationException e )
		{
			ic.sendError( "You're, uh, not really allowed to do that..." );
		}
	}
	
	public static class player extends Create
	{
		public player()
		{
			setKey( "player" );
			usage = "<name> <password>";
		}
		
		public void run( Player p, StringTokenizer args, String fullLine, CategoryCommand caller, InteractiveConnection ic, Flags flags ) throws IOException
		{
			Atom created = null;
			Container place = null;
			String successFeedback;
			
			String id = nextArgument( args, ic );
			String password = nextArgument( args, ic );
			
			place = Key.instance().getResidents();
			created = (key.Player) Factory.makeAtom( Player.class, id );
			created.setProperty( "canSave", Boolean.TRUE );
			((key.Player)created).setPassword( password );
			
			successFeedback = "Created player " + id + " with password '" + password + "'";
			
			this.add( ic, created, place, successFeedback );
			
				//  we might as well do this here, it has
				//  to be done, or the player will be a
				//  newbie forever. ;0
			created.sync();
		}
	}
	
	public static class object extends Create
	{
		public object()
		{
			setKey( "object" );
			usage = "<number>";
		}
		
		public void run( Player p, StringTokenizer args, String fullLine, CategoryCommand caller, InteractiveConnection ic, Flags flags ) throws IOException
		{
			String num = nextArgument( args, ic );
			int n = 0;
			Atom created = null;
			Container place = null;
			
			place = (Container) new Search( "/realm.objects", null ).result;
			
			try
			{
				n = Integer.parseInt( num );
			}
			catch( NumberFormatException e )
			{
				ic.sendError( "'" + num + "' is not a number." );
				return;
			}
			
			if( place == null )
			{
				ic.sendError( "Could not locate /realm.objects" );
				return;
			}
			
			created = (Atom) place.getElementAt( n );
			
			if( created == null || (!(created instanceof Thing)) )
			{
				ic.sendError( "Could not find object number " + n );
				return;
			}
			
			Reference r = ((Thing)created).build( p );
			
			if( r != null )
			{
				Atom a = r.get();
				
				if( a != null )
				{
					try
					{
						p.getInventory().add( a );
					}
					catch( Exception e )
					{
						ic.sendFailure( e.toString() + " during build." );
					}
					
					ic.send( "Built: " + a.getId() );
				}
				else
					ic.sendError( "Build failed" );
			}
			else
				ic.sendError( "Build failed" );
		}
	}
	
	public static class objecttype extends Create
	{
		public objecttype()
		{
			setKey( "objecttype" );
			usage = "<primary-name> <java-class>";
		}
		
		public void run( Player p, StringTokenizer args, String fullLine, CategoryCommand caller, InteractiveConnection ic, Flags flags ) throws IOException
		{
			String id = nextArgument( args, ic );
			Atom created = null;
			Container place = null;
			String successFeedback;
				
			String classType = nextArgument( args, ic );
						
			place = (Container) new Search( "/realm.objects", null ).result;
						
			try
			{
				Class c = Class.forName( "key." + classType );
				
				if( !Thing.class.isAssignableFrom( c ) )
				{
					ic.sendFailure( "That class does not implement Thing" );
					return;
				}
				
				created = (Atom) Factory.makeAtom( c, id );
				
				successFeedback = "Created a " + ((Thing)created).getFullPortrait( p );
			}
			catch( Exception e )
			{
				ic.sendError( e.toString() );
				return;
			}
			
			this.add( ic, created, place, successFeedback );
		}
	}
	
	public static class room extends Create
	{
		public room()
		{
			setKey( "room" );
			usage = "<id> [<name>]";
		}
		
		public void run( Player p, StringTokenizer args, String fullLine, CategoryCommand caller, InteractiveConnection ic, Flags flags ) throws IOException
		{
			String id = nextArgument( args, ic );
			Atom created  = null;
			Container place = null;
			String successFeedback;
			String name;
			
			if( id.length() > Atom.MAX_KEY_LENGTH )
			{
				ic.sendFeedback( "That id is too long for a room." );
				return;
			}
			
				//  check for a name for the room
			if( args.hasMoreTokens() )
				name = args.nextToken( "" );
			else //  set the default room name
				name =  p.getName() + "'s boring room";
			
			Atom a = p.getContext();
			
			try
			{
				place = (Container) a;
			}
			catch( ClassCastException e )
			{
				ic.sendError( a.getName() + " isn't a container of any sort, and can't be used to hold things.  Sorry.  No, really, I am." );
				return;
			}
			
			created = (Room) Factory.makeAtom( Room.class, id );
			
				// set the default room title to <names>'s boring room
			created.setProperty( "called", "^h" + name + "^-" ); 
			
			successFeedback = "Built the room '" + id + "' (in " + place.getName() + ")";
		
			this.add( ic, created, place, successFeedback );
			
			if( place instanceof Player )
			{
				Player pl = (Player) place;
				
				if( pl.countRooms() == 1 )
				{
						//  set it to be their home room
					pl.setHome( (Room) created );
					
					if( pl == p )
						ic.sendFeedback( "This room has also been set to your home, since you don't have any others." );
					else
						ic.sendFeedback( "Since " + pl.getName() + " doesn't have any other rooms, this room has also been set as " + pl.hisHer() + " home." );
				}
			}
		}
	}
	
	public static class exit extends Create
	{
		public exit()
		{
			setKey( "exit" );
			usage = "<id> <destination room>";
		}
		
		public void run( Player p, StringTokenizer args, String fullLine, CategoryCommand caller, InteractiveConnection ic, Flags flags ) throws IOException
		{
			String id = nextArgument( args, ic );
			Atom created = null;
			Container place = null;
			String successFeedback;
			String name;
			
			if( id.length() > Atom.MAX_KEY_LENGTH )
			{
				ic.sendFeedback( "That name is too long for an exit." );
				return;
			}
			
			Room dest = null;
			
			if( !args.hasMoreTokens() )
			{
				usage( ic );
				return;
			}
			
			String toId = args.nextToken();
			Atom ctx = null;
			
			if( toId.indexOf( '/' ) == -1 )
				ctx = p.getContext();
			else
				ctx = Key.shortcuts();
			
				//  exits must have a place to go...
			dest = (Room) getSymbolInside( ic, toId, Type.ROOM, ctx );
			
			if( dest != null )
			{
				place = p.getLocation();
				
				if( place == null )
				{
					ic.sendError( "You don't appear to, uh, *be* anywhere" );
					return;
				}
				
				created = (Exit) Factory.makeAtom( Exit.class, id );
				((Exit) created).setTo( (Room)dest );
				successFeedback = "Built the exit " + id + " in " + place.getName() + ", which leads to " + dest.portrait() + " (" + dest.getName() + ")";
			}
			else
				return;
			
			this.add( ic, created, place, successFeedback );
		}
	}
	
	public static class clan extends Command
	{
		public static final int MAX_RANKS = 7;
		public static final String COUNCIL_ID = "/online/channels/council";
		
		public clan()
		{
			setKey( "clan" );
			usage = "<founder> <clan name> ";
		}
		
		public void run( Player p, StringTokenizer args, String fullLine, CategoryCommand caller, InteractiveConnection ic, Flags flags ) throws IOException
		{
			String type;
			String playerName = nextArgument( args, ic );
			String clanName = nextArgument( args, ic );
			
				//  get the targeted player
			Player targetPlayer = (Player) getPlayer( ic, playerName );
			
			if( targetPlayer == null )
				return;
			
			if( clanName.length() > Clan.MAX_NAME )
			{
				ic.sendFeedback( "That is too long for a Clan name, sheesh!" );
				return;
			}
			
				// Check to see if the person who a clan is being made
				// for is already in a clan, we *don't* want clans
				// created for those who are in one already!!
			
			Clan currentClan = (Clan) targetPlayer.getClan();
			if( currentClan != null )
			{
				ic.sendError( "'" + targetPlayer.getName() + "' is already in a Clan!" );
				return;
			}
			
			Container sc = Key.shortcuts();
			Object o = sc.getExactElement( clanName );
			if( o != null && !(o instanceof Trie) )
			{
				ic.sendError( "There is already something of this name." );
				return;
			}
			
				// has a verified player and the next string,
				// time to form the clan!
				
				// equivalent to instant Clan, it also puts it 
				// under the player who issued the Create_Clan command.
			
			Clan clan = (Clan) Factory.makeAtom( Clan.class, clanName );
			
				// we do this, to catch BadKeyException errors
				// and NonUniqueKeyException errors
			
			try
			{
				((Container)Key.instance().getElement( "clans" )).add( clan );	
			}
			catch( BadKeyException e )
			{
				ic.sendError( "'" + clanName + "' should contain only alphabetic characters" );
				return;
			}
			catch( NonUniqueKeyException e )
			{
				ic.sendError( "There is already something of that name here" );
				return;
			}
			
				// set the founder of the clan to the name specified
				// in the command (player existence already verified!)
			clan.setFounder( targetPlayer );
			
				// and set player field clan entry to their clan
			targetPlayer.enrolIntoClan( clan );
			
			clan.setRecursiveOwner( targetPlayer );
			
				// all done, send some feedback about the clan created and log it
			ic.sendFeedback( "Clan '" + clan.getName() + "' formed, with founder " + targetPlayer.getName() );
			
			if( targetPlayer != p && targetPlayer.connected() )
				targetPlayer.send( "Clan '" + clan.getName() + "' has been created for you." );
			
			String fm = p.getName() + " formed Clan '" + clan.getName() + "' for " + targetPlayer.getName();
			
			Group g = null;
			
			try
			{
				g = (Group) new Search( COUNCIL_ID, null ).result;
			}
			catch( ClassCastException e )
			{
			}
			
			if( g == null )
			{
				ic.sendFailure( "Could not find " + COUNCIL_ID );
				Log.log( "clan", "'" + COUNCIL_ID + "' not found looking for council" );
			}
			else
			{
				try
				{
					g.add( targetPlayer );
				}
				catch( Exception e )
				{
					String err = "Could not add " + targetPlayer.getName() + " to council: " + e.toString();
					ic.sendFailure( err );
					Log.log( "clan", err );
				}
			}
			
			Log.log( "clans/" + clan.getName() + ".records", fm );
			Log.log( "clan" , fm );
		}
	}
}