package me.timothy.consolegui;

import java.util.HashMap;
import java.util.Iterator;
import java.text.NumberFormat;
import java.text.DecimalFormat;

import javax.swing.SwingUtilities;
/**
 * This class includes a command registry system
 * and several default commands.  The static methods
 * from ConsoleGUI can be used.
 * 
 * Note that the console will look for a 'default' in the 
 * commands HashMap if an unknown command is typed. By default,
 * this will call 'help'. Help will be updated on called updateHelp(),
 * which will take all of the names and descriptions and make a fast
 * println.
 * 
 * @author Timothy Moore
 */
public class ServerConsole extends ConsoleGUI {
  private HashMap<String[], CommandListener> commands;
  private static ServerConsole uncastedGUI;
  
  private String currentHelp;
  
  private ServerConsole() {
    super();
    commands = new HashMap<String[], CommandListener>();
  }
  
  /**
   * Creates an empty console to show default commands
   */
  public static void main(String[] args) {
    toGUI();
    ConsoleGUI.setSaveText(true);
    TAScanner scanner = ConsoleGUI.getScanner();
    TAPrintStream out = ConsoleGUI.getStream();
  }
  
  /**
   * Registers the command and updates the help document. A few special commands
   * that are registered by default, however they can be overriden:
   * <ul>
   * <li>help - Lists 
   * <li>memory - Will list current memory, used memory and available memory
   * <li>default - Called whenever an unexpected/unregistered command is used.
   * </ul>
   * 
   * @param cmName the name of the command
   * @param description the description of the command
   * @param listener the listener to call if that command is made
   */
  public static void registerCommand(String cmName, String description, 
                                     CommandListener listener) {
    String[] command = new String[] { cmName, description };
    
    getGUI().commands.put(command, listener);
  }
  
  /**
   * Overrides the help command with the current
   * commands and their descriptions.
   */
  public static String updateHelp() {
    Iterator it = getGUI().commands.keySet().iterator();
    
    StringBuilder res = new StringBuilder("");
    while(it.hasNext()) {
      String[] str = (String[]) it.next();
      
      if(!str[0].equals("default")) {
        res.append(str[0]).append(" - ").append(str[1]).append("\n");
      }
    }
    getGUI().currentHelp = res.toString();
    return getGUI().currentHelp;
  }
  
  /**
   * Acts similiarly to the ConsoleGUI's method, except includes
   * registrying commands.
   */
  public static void toGUI() { 
    try
    {
      if(!SwingUtilities.isEventDispatchThread())
      {
        SwingUtilities.invokeAndWait(new Runnable() {
          @Override
          public void run()
          {
            gui = new ServerConsole();
            gui.setTitle("Server Console");
            uncastedGUI = (ServerConsole) gui;
            ConsoleGUI.gui = uncastedGUI;
            gui.stream = gui.createPrintStream();
            
            uncastedGUI.registerSpecial();
            uncastedGUI.updateHelp();
            gui.setVisible(true);
          }
        });
      }else
      {
        gui = new ServerConsole();
        uncastedGUI = (ServerConsole) gui;
        ConsoleGUI.gui = uncastedGUI;
        gui.stream = gui.createPrintStream();
        
        uncastedGUI.registerSpecial();
        uncastedGUI.updateHelp();
        gui.setVisible(true);
      }
      
      // Now prepare the command loop
      Runnable loop = new Runnable() {
        @Override
        public void run() {
          while(true) {
            String str = getScanner().readLine();
            String[] spl = str.split(" ");
            String[] params = java.util.Arrays.copyOfRange(spl, 1, spl.length);
            // This could be optimized, however it doesn't matter because they will
            // not be doing very many commands, so this really won't make a difference
            // unless there are a lot of commands.
            
            for(String[] cmd : getGUI().commands.keySet()) {
              if(cmd[0].equalsIgnoreCase(str)) {
                getGUI().commands.get(cmd).onCommand(str, params);
                break;
              }
            }
          }
        }
      };
      new Thread(loop).start();
    }catch(Exception exc)
    {
      handleException("Failed to convert to gui", exc, saveRun);
    }
  }
  
  public static ServerConsole getGUI() {
    return uncastedGUI;
  }
  
  /**
   * Registers special commands, such as help, default and memory
   */
  protected void registerSpecial() {
    CommandListener listener = new CommandListener() {
      @Override
      public void onCommand(String nm, String[] param) {
        TAPrintStream strm = getStream();
        if(nm.equalsIgnoreCase("help") || nm.equalsIgnoreCase("default")) {
          strm.print(getGUI().currentHelp);
        }else if(nm.equalsIgnoreCase("memory")) {
          long maxMemoryN = Runtime.getRuntime().maxMemory();
          long totalMemN = Runtime.getRuntime().totalMemory();
          long freeMemN = Runtime.getRuntime().freeMemory();
          long usedMemoryN = totalMemN - freeMemN;
          
          NumberFormat f = NumberFormat.getInstance();
          String maxMemory = f.format(maxMemoryN) + " (" + getReasonable(maxMemoryN)+ ")";
          String totalMem = f.format(totalMemN) + " (" + getReasonable(totalMemN) + ")";
          String freeMem = f.format(freeMemN) + " (" + getReasonable(freeMemN) + ")";
          String usedMemory = f.format(usedMemoryN) + " (" + getReasonable(usedMemoryN) + ")";
          
          StringBuilder mem = new StringBuilder("Allocated Memory / Max Memory: ");
          mem.append(maxMemoryN == Long.MAX_VALUE ? totalMem : maxMemory).append("\nTotal Memory: ");
          mem.append(totalMem).append("\nFree Memory: ");
          mem.append(freeMem).append("\nUsed Memory: ").append(usedMemory);
          
          strm.println(mem.toString());
        }
      }
    };
    
    registerCommand("memory", "Prints memory usage and information", listener);
    registerCommand("help", "Prints this list of commands", listener);
    registerCommand("default", "Prints this list of commands", listener);
    
  }
  
  private static final long KILO_BYTE = 1024;
  private static final long MEGA_BYTE = KILO_BYTE * 1024;
  private static final long GIGA_BYTE = MEGA_BYTE * 1024;
  
  /**
   * Converts bytes to something more reasonable, eg 5000 bytes to 4.something 
   * kilobytes.
   * 2,051,280 bytes is much harder to understand than 1.96 megabytes
   * 
   * @param l the number of bytes
   */
  public static String getReasonable(long l) {
    DecimalFormat formater = new DecimalFormat("####.##");
    if(l > GIGA_BYTE) { 
      double d = l / (double) GIGA_BYTE;
      return formater.format(d) + " gigabytes";
    }else if(l > MEGA_BYTE) {
      double d = l / (double) MEGA_BYTE;
      return formater.format(d) + " megabytes";
    }else {
      double d = l / (double) KILO_BYTE;
      return formater.format(d) + " kilobytes";
    }
  }
}