/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License as published by
    *  the Free Software Foundation.
    *
   *  This program is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *  along with this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.plugin.opennap.net;
  
  import java.awt.event.ActionEvent;
  import java.io.IOException;
  
  import javax.swing.Action;
  import javax.swing.Icon;
  
  import org.xnap.chat.ChatProvider;
  import org.xnap.chat.action.AbstractBanAction;
  import org.xnap.chat.action.AbstractDeOpAction;
  import org.xnap.chat.action.AbstractJoinAction;
  import org.xnap.chat.action.AbstractOpAction;
  import org.xnap.chat.action.AbstractPartAction;
  import org.xnap.chat.command.*;
  import org.xnap.chat.command.AbstractPartChannelCommand;
  import org.xnap.chat.command.JoinChannelCommand;
  import org.xnap.cmdl.Command;
  import org.xnap.cmdl.Console;
  import org.xnap.peer.Peer;
  import org.xnap.plugin.opennap.OpenNapPlugin;
  import org.xnap.plugin.opennap.command.OpenNapBanListCommand;
  import org.xnap.plugin.opennap.command.OpenNapMessageCommand;
  import org.xnap.plugin.opennap.command.OpenNapRegisterUserCommand;
  import org.xnap.plugin.opennap.net.msg.MessageHandler;
  import org.xnap.plugin.opennap.net.msg.MessageListener;
  import org.xnap.plugin.opennap.net.msg.client.ChannelBanMessage;
  import org.xnap.plugin.opennap.net.msg.client.ChannelTopicMessage;
  import org.xnap.plugin.opennap.net.msg.client.*;
  import org.xnap.plugin.opennap.net.msg.client.PartChannelMessage;
  import org.xnap.plugin.opennap.net.msg.client.PublicMessage;
  import org.xnap.plugin.opennap.net.msg.client.RemoveChannelOpMessage;
  import org.xnap.plugin.opennap.net.msg.client.SetChannelOpMessage;
  import org.xnap.plugin.opennap.net.msg.server.ErrorMessage;
  import org.xnap.plugin.opennap.net.msg.server.ServerMessage;
  
  /***
   * Represents a single channel on a server.
   */
  public class OpenNapChannel extends OpenNapAbstractChannel implements MessageListener
  {
  
      //--- Constant(s) ---
  
      //--- Data field(s) ---
  
      private boolean joined = false;
      private int userCount;
  
  	private Action acJoin = new JoinAction();
  	private Action acPart = new PartAction();
  
      //--- Constructor(s) ---
  
      public OpenNapChannel(OpenNapServer server, String name)
      {
  		super(server, name);
  
  		acPart.setEnabled(false);
  
  		MessageHandler.subscribe(ErrorMessage.TYPE, this);
      }
  
      //--- Method(s) ---
  
      public void add(Peer peer)
      {
  		super.add(peer);
  		setUserCount(super.getPeerCount());
      }
  
      public void changeTopic(String newValue) throws IOException
      {
  		ChannelTopicMessage m = new ChannelTopicMessage(getName(), newValue);
  		m.setExceptionListener(this);
  		MessageHandler.send(server, m);
      }
  
      public void close()
      {
 		if (joined) {
 			MessageHandler.unsubscribe(ErrorMessage.TYPE, this);
 
 			joined = false;
 			MessageHandler.send(server, new PartChannelMessage(getName()));
 		}
     }
 
     public Action[] getActions()
     {
 		return new Action[] { acJoin, acPart, };
     }
 
 	public Command[] getCommands()
 	{
 		return new Command[] { 
 			new OpenNapMessageCommand(this), 
 			new OpenNapRegisterUserCommand(this), 
 			new OpenNapBanListCommand(this, getName()), 
 			new BanCommand(),
 			new IgnoreCommand(),
 			new MeCommand(),
 			new JoinChannelCommand(server, getName()),
 			new PartChannelCommand(),
 		};
 	}
 
     /***
      * @see OpenNapPlugin.ICON_16.
      */
     public Icon getIcon()
     {
 		return OpenNapPlugin.ICON_16;
     }
 
     public Action[] getPeerActions(Peer peer)
     {
 		return new Action[] {
 			new OpAction(peer), new DeOpAction(peer), 
 			new BanAction(peer), 
 		};
     }
 
     public int getPeerCount()
     {
 		return userCount;
     }
 
     public ChatProvider getProvider()
     {
 		return server;
     }
 
     public boolean isJoined()
     {
 		return joined;
     }
 
     public void join()
     {
 		JoinChannelMessage m = new JoinChannelMessage(getName());
 		m.setExceptionListener(this);
 		MessageHandler.send(server, m);
     }
 
     public void messageReceived(ServerMessage msg) 
     {
 		if (msg.getServer() != server) {
 			return;
 		}
 
 		errorReceived(((ErrorMessage)msg).message);
     }
 
     public void sendMessage(String message)
     {
 		// split message if it's too large
 		for (int i = 0; i < message.length(); i += 174) {
 			int end = Math.min(i + 174, message.length());
 			PublicMessage m = new PublicMessage(getName(), 
 												message.substring(i, end));
 			m.setExceptionListener(this);
 			MessageHandler.send(server, m);
 		}
 	
     }
 
 	public void setJoined(boolean joined, String reason)
 	{
 		if (this.joined != joined) {
 			this.joined = joined;
 			if (joined) {
 				joined();
 			}
 			else {
 				parted(reason);
 			}
 
 			acJoin.setEnabled(!joined);
 			acPart.setEnabled(joined);
 		}
 	}
 
     public void setUserCount(int userCount)
     {
 		this.userCount = userCount;
     }
 
     public boolean equals(Object o)
     {
 		if (o instanceof OpenNapChannel) {
 			OpenNapChannel c = (OpenNapChannel)o;
 			return (getProvider() == c.getProvider()) 
 				&& getName().equalsIgnoreCase(c.getName());
 		}
 		return false;
     }
 
     //--- Inner Class(es) ---
 
     private class BanAction extends AbstractBanAction
     {
 		private Peer peer;
 
 		public BanAction(Peer peer)
 		{
 			this.peer = peer;
 		}
 
         public void actionPerformed(ActionEvent event) 
 		{
 			ChannelBanMessage msg 
 				= new ChannelBanMessage(OpenNapChannel.this.getName(), 
 										peer.getName());
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
     }
 
     private class DeOpAction extends AbstractDeOpAction
     {
 		private Peer peer;
 
 		public DeOpAction(Peer peer)
 		{
 			this.peer = peer;
 		}
 
         public void actionPerformed(ActionEvent event) 
 		{
 			RemoveChannelOpMessage msg 
 				= new RemoveChannelOpMessage(OpenNapChannel.this.getName(), 
 											 peer.getName());
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
     }
 
     private class JoinAction extends AbstractJoinAction
     {
 
         public void actionPerformed(ActionEvent event) 
 		{
 			join();
 		}
 
 	}
 
     private class OpAction extends AbstractOpAction
     {
 		private Peer peer;
 
 		public OpAction(Peer peer)
 		{
 			this.peer = peer;
 		}
 
         public void actionPerformed(ActionEvent event) 
 		{
 			SetChannelOpMessage msg 
 				= new SetChannelOpMessage(OpenNapChannel.this.getName(), 
 										  peer.getName());
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
     }
 
     private class PartAction extends AbstractPartAction
     {
         public void actionPerformed(ActionEvent event) 
 		{
 			PartChannelMessage msg 
 				= new PartChannelMessage(OpenNapChannel.this.getName());
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
 	}
 
 	//--- Command Classes ---
 
 	private class BanCommand extends AbstractBanCommand
 	{
 		public void send(Console console, String channelName, String nick,
 						 String reason)
 		{
 			ChannelBanMessage msg 
 				= new ChannelBanMessage(channelName, nick, reason);
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
 	}
 
 	private class IgnoreCommand extends AbstractIgnoreUserCommand
 	{
 		public void send(Console console, String nick)
 		{
 			AddUserToIgnoreListMessage msg 
 				= new AddUserToIgnoreListMessage(nick);
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
 	}
 
 	private class MeCommand extends AbstractMeCommand
 	{
 		public void send(Console console, String action)
 		{
 			EmoteMessage msg
 				= new EmoteMessage(OpenNapChannel.this.getName(), action);
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
 	}
 
 	private class PartChannelCommand extends AbstractPartChannelCommand
 	{
 		public void part(String channel)
 		{
 			PartChannelMessage msg 
 				= new PartChannelMessage((channel != null) 
 										 ? channel
 										 : OpenNapChannel.this.getName());
 			msg.setExceptionListener(OpenNapChannel.this);
 			MessageHandler.send(server, msg);
 		}
 	}
 
 }