/*
      Copyright 2009 Ramon Servadei
   
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
   
          http://www.apache.org/licenses/LICENSE-2.0
   
     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
   */
  package fulmine.demo;
  
  import java.awt.BorderLayout;
  import java.awt.GridLayout;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.KeyEvent;
  
  import javax.swing.BorderFactory;
  import javax.swing.JButton;
  import javax.swing.JComboBox;
  import javax.swing.JFrame;
  import javax.swing.JLabel;
  import javax.swing.JMenu;
  import javax.swing.JMenuBar;
  import javax.swing.JMenuItem;
  import javax.swing.JOptionPane;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;
  import javax.swing.JTextField;
  import javax.swing.WindowConstants;
  
  import fulmine.Domain;
  import fulmine.Type;
  import fulmine.context.FulmineContext;
  import fulmine.context.IFulmineContext;
  import fulmine.context.IPermissionProfile;
  import fulmine.context.RemoteUpdateHandler;
  import fulmine.distribution.connection.tcp.TcpNetwork;
  import fulmine.model.container.IContainer;
  import fulmine.model.container.impl.Record;
  import fulmine.model.field.FieldUtils;
  import fulmine.ui.RecordTable;
  import fulmine.ui.SwingWorker;
  
  /**
   * A GUI application for demonstrating the abilities of the system.
   * 
   * @author Ramon Servadei
   */
  public final class DemoApp
  {
  
      public DemoApp()
      {
          super();
      }
  
      /**
       * Creates all necessary GUI components. It is rather monolithic but this is
       * purely a demo app (so does that mean good design principles should be
       * abandoned!? No, but its hard to get good component based designs when
       * constructing GUI components...not an excuse, just a statement of fact and
       * being an advocate of the 80/20 rule its better not to over engineer
       * this).
       * 
       * @throws Exception
       */
      public void start() throws Exception
      {
          // gather parameters
          SwingWorker<ContextParameters> worker =
              new SwingWorker<ContextParameters>()
              {
                  @Override
                  public ContextParameters doWork() throws Exception
                  {
                      return new ContextParameters("DemoApp:parameters");
                  }
              };
          final ContextParameters params = worker.invokeAndWait().getResult();
          synchronized (params)
          {
              try
              {
                  params.wait();
              }
              catch (InterruptedException e)
              {
                  e.printStackTrace();
              }
          }
          // now create the context
         final IFulmineContext context =
             new FulmineContext(params.getContextName());
         context.setNetwork(new TcpNetwork((String) null,
             Integer.parseInt(params.getTcpPort())));
         // create a permission profile based on the params - this does an exact
         // match for the application and permission codes
         context.setPermissionProfile(new IPermissionProfile()
         {
 
             public boolean contains(byte application, short permission)
             {
                 return application == getApplicationCode()
                     && permission == getPermissionCode();
             }
 
             public byte getApplicationCode()
             {
                 return Byte.parseByte(params.getApplicationCode());
             }
 
             public short getPermissionCode()
             {
                 return Short.parseShort(params.getPermissionCode());
             }
 
             public boolean matches(byte receivedApplication,
                 short receivedPermission, byte matchWithApplication,
                 short matchWithPermission)
             {
                 return receivedApplication == matchWithApplication
                     && receivedPermission == matchWithPermission;
             }
         });
         context.setRemoteUpdateHandler(new RemoteUpdateHandler());
         context.start();
         System.out.println("Application ready");
         System.out.println(params);
 
         // now create a JFrame for the table listener
         SwingWorker<RecordTable> recordTableCreator =
             new SwingWorker<RecordTable>()
             {
                 @Override
                 public RecordTable doWork() throws Exception
                 {
                     final RecordTable recordTable = new RecordTable();
                     recordTable.setRowSelectionAllowed(true);
                     return recordTable;
                 }
             };
 
         final RecordTable recordTable =
             recordTableCreator.invokeAndWait().getResult();
 
         SwingWorker<JFrame> mainFrameCreator = new SwingWorker<JFrame>()
         {
             @Override
             public JFrame doWork() throws Exception
             {
                 JFrame mainFrame = new JFrame("DemoApp:" + params);
                 final JMenuBar menuBar = new JMenuBar();
                 mainFrame.setJMenuBar(menuBar);
                 final JMenu recordMenu = new JMenu("Actions");
                 menuBar.add(recordMenu);
                 JScrollPane scrollPane = new JScrollPane(recordTable);
                 recordTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
                 mainFrame.getContentPane().add(scrollPane);
                 final JMenuItem menuItemAdd =
                     new JMenuItem("Add Record", KeyEvent.VK_A);
                 menuItemAdd.addActionListener(new ActionListener()
                 {
                     public void actionPerformed(ActionEvent e)
                     {
                         final GetRecordParameters window =
                             new GetRecordParameters("Add record parameters");
                         window.addActionListener(new ActionListener()
                         {
                             public void actionPerformed(ActionEvent e)
                             {
                                 context.getLocalContainer(
                                     window.getIdentity(),
                                     Type.get(Integer.parseInt(window.getType())),
                                     Domain.get(Integer.parseInt(window.getDomain())));
                                 context.subscribe(
                                     context.getIdentity(),
                                     window.getIdentity(),
                                     Type.get(Integer.parseInt(window.getType())),
                                     Domain.get(Integer.parseInt(window.getDomain())),
                                     recordTable);
                             }
                         });
                     }
                 });
                 final JMenuItem menuItemRemove =
                     new JMenuItem("Remove Record", KeyEvent.VK_R);
                 menuItemRemove.addActionListener(new ActionListener()
                 {
                     public void actionPerformed(ActionEvent e)
                     {
                         final Record selectedRecord =
                             recordTable.getSelectedRecord();
                         if (selectedRecord != null && selectedRecord.isLocal())
                         {
                             context.getLocalContainer(
                                 selectedRecord.getIdentity(),
                                 selectedRecord.getType(),
                                 selectedRecord.getDomain()).destroy();
                         }
                     }
                 });
                 final JMenuItem menuItemAddField =
                     new JMenuItem("Add Field", KeyEvent.VK_F);
                 menuItemAddField.addActionListener(new ActionListener()
                 {
                     public void actionPerformed(ActionEvent e)
                     {
                         final AddFieldParameters window =
                             new AddFieldParameters("Add field");
                         window.addActionListener(new ActionListener()
                         {
                             public void actionPerformed(ActionEvent e)
                             {
                                 // get the selected record, construct the field
                                 // and add the field
                                 try
                                 {
                                     final Record selectedRecord =
                                         recordTable.getSelectedRecord();
                                     if (selectedRecord.isLocal())
                                     {
                                         final IContainer localContainer =
                                             context.getLocalContainer(
                                                 selectedRecord.getIdentity(),
                                                 selectedRecord.getType(),
                                                 selectedRecord.getDomain());
                                         localContainer.add(FieldUtils.createFromString(
                                             window.getType(),
                                             window.getIdentity(),
                                             Byte.parseByte(window.getApplicationCode()),
                                             Short.parseShort(window.getPermissionCode())));
                                         localContainer.flushFrame();
                                     }
                                 }
                                 catch (RuntimeException ex)
                                 {
                                     JOptionPane.showMessageDialog(null,
                                         "Select a record and try again");
                                     throw ex;
                                 }
                             }
                         });
                     }
                 });
                 final JMenuItem menuItemRemoveField =
                     new JMenuItem("Remove Field", KeyEvent.VK_E);
                 menuItemRemoveField.addActionListener(new ActionListener()
                 {
                     public void actionPerformed(ActionEvent e)
                     {
                         // get the selected record, construct the field
                         // and add the field
                         try
                         {
                             final Record selectedRecord =
                                 recordTable.getSelectedRecord();
                             if (selectedRecord.isLocal())
                             {
                                 final IContainer localContainer =
                                     context.getLocalContainer(
                                         selectedRecord.getIdentity(),
                                         selectedRecord.getType(),
                                         selectedRecord.getDomain());
                                 localContainer.remove(recordTable.getSelectedField());
                                 localContainer.flushFrame();
                             }
                         }
                         catch (RuntimeException ex)
                         {
                             JOptionPane.showMessageDialog(null,
                                 "Select a record and try again");
                             throw ex;
                         }
                     }
                 });
                 final JMenuItem menuItemSubscribe =
                     new JMenuItem("Subscribe Record", KeyEvent.VK_S);
                 menuItemSubscribe.addActionListener(new ActionListener()
                 {
                     public void actionPerformed(ActionEvent e)
                     {
                         final SubscribeRecordParameters window =
                             new SubscribeRecordParameters(
                                 "Subscribe parameters");
                         window.addActionListener(new ActionListener()
                         {
                             public void actionPerformed(ActionEvent e)
                             {
                                 context.subscribe(
                                     window.getContextIdentity(),
                                     window.getIdentity(),
                                     Type.get(Integer.parseInt(window.getType())),
                                     Domain.get(Integer.parseInt(window.getDomain())),
                                     recordTable);
                             }
                         });
                     }
                 });
                 final JMenuItem menuItemUnsubscribe =
                     new JMenuItem("Unsubscribe Record", KeyEvent.VK_U);
                 menuItemUnsubscribe.addActionListener(new ActionListener()
                 {
                     public void actionPerformed(ActionEvent e)
                     {
                         final SubscribeRecordParameters window =
                             new SubscribeRecordParameters(
                                 "Unsubscribe parameters");
                         window.addActionListener(new ActionListener()
                         {
                             public void actionPerformed(ActionEvent e)
                             {
                                 context.unsubscribe(
                                     window.getContextIdentity(),
                                     window.getIdentity(),
                                     Type.get(Integer.parseInt(window.getType())),
                                     Domain.get(Integer.parseInt(window.getDomain())),
                                     recordTable);
                             }
                         });
                     }
                 });
                 recordMenu.add(menuItemAdd);
                 recordMenu.add(menuItemRemove);
                 recordMenu.add(menuItemAddField);
                 recordMenu.add(menuItemRemoveField);
                 recordMenu.add(menuItemSubscribe);
                 recordMenu.add(menuItemUnsubscribe);
                 mainFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
                 mainFrame.pack();
                 mainFrame.setVisible(true);
                 return mainFrame;
             }
         };
         mainFrameCreator.invokeAndWait();
     }
 
     public static void main(String[] args) throws Exception
     {
         new DemoApp().start();
     }
 }
 
 /**
  * Base class for a GUI that gathers parameters
  * 
  * @author Ramon Servadei
  */
 abstract class ParameterGatherer extends JFrame
 {
     private static final long serialVersionUID = 1L;
 
     final JButton ok = new JButton("OK");
 
     ParameterGatherer(String title)
     {
         super(title);
         getContentPane().setLayout(new BorderLayout());
         ok.addActionListener(new ActionListener()
         {
             public void actionPerformed(ActionEvent e)
             {
                 synchronized (ParameterGatherer.this)
                 {
                     ParameterGatherer.this.notify();
                 }
                 ParameterGatherer.this.dispose();
             }
         });
         getContentPane().add(ok, BorderLayout.SOUTH);
     }
 
     /**
      * Add the {@link ActionListener} to the actions performed when the "OK"
      * button is pressed
      * 
      * @param listener
      *            the listener to add
      */
     void addActionListener(ActionListener listener)
     {
         this.ok.addActionListener(listener);
     }
 
     /**
      * Call to pack and set visible
      */
     void postInit()
     {
         pack();
         setVisible(true);
     }
 }
 
 /**
  * A simple UI for gathering parameters about creating a context.
  * 
  * @author Ramon Servadei
  */
 final class ContextParameters extends ParameterGatherer
 {
     private static final long serialVersionUID = 1L;
 
     final Parameter contextName, tcpPort, applicationCode, permissionCode;
 
     ContextParameters(String title)
     {
         super(title);
         JPanel params = new JPanel();
         params.setLayout(new GridLayout(4, 2));
         this.contextName =
             new Parameter(params, "Context name", "choose a unique name");
         this.tcpPort =
             new Parameter(params, "TCP port", "choose an unused TCP port");
         this.applicationCode =
             new Parameter(params, "Application code (byte)", "0");
         this.permissionCode =
             new Parameter(params, "Permission code (short)", "0");
         getContentPane().add(params);
         postInit();
     }
 
     /**
      * @return the value of the context name field
      */
     String getContextName()
     {
         return this.contextName.getValue();
     }
 
     /**
      * @return the value of the tcp port field
      */
     String getTcpPort()
     {
         return this.tcpPort.getValue();
     }
 
     /**
      * @return the value of the application code field
      */
     String getApplicationCode()
     {
         return this.applicationCode.getValue();
     }
 
     /**
      * @return the value of the permission code field
      */
     String getPermissionCode()
     {
         return this.permissionCode.getValue();
     }
 
     @Override
     public String toString()
     {
         return "Context name=" + getContextName() + ", TCP port="
             + getTcpPort() + ", application code=" + getApplicationCode()
             + ", permission code=" + getPermissionCode();
     }
 }
 
 /**
  * Encapsulates a {@link JLabel} and {@link JTextField} for a single parameter
  * 
  * @author Ramon Servadei
  */
 final class Parameter
 {
     private static final long serialVersionUID = 1L;
 
     final JLabel name;
 
     final JTextField value;
 
     Parameter(JPanel parent, String name, String value)
     {
         super();
         this.name = new JLabel(name);
         this.name.setBorder(BorderFactory.createEtchedBorder());
         this.value = new JTextField(value);
         parent.add(this.name);
         parent.add(this.value);
     }
 
     String getValue()
     {
         return value.getText();
     }
 }
 
 /**
  * Encapsulates a {@link JLabel} and {@link JComboBox} for a field type
  * parameter
  * 
  * @author Ramon Servadei
  */
 final class FieldTypeParameter
 {
     private static final long serialVersionUID = 1L;
 
     final JLabel name;
 
     final JComboBox value;
 
     FieldTypeParameter(JPanel parent, String name)
     {
         super();
         this.name = new JLabel(name);
         this.name.setBorder(BorderFactory.createEtchedBorder());
         this.value =
             new JComboBox(new String[] { "StringField", "BooleanField",
                 "IntegerField", "LongField", "FloatField", "DoubleField" });
         parent.add(this.name);
         parent.add(this.value);
     }
 
     String getValue()
     {
         return (String) value.getSelectedItem();
     }
 }
 
 /**
  * Encapsulates parameters required to add a record
  * 
  * @author Ramon Servadei
  */
 class AddFieldParameters extends ParameterGatherer
 {
     private static final long serialVersionUID = 1L;
 
     final Parameter identity, applicationCode, permissionCode;
 
     final FieldTypeParameter type;
 
     final JPanel params;
 
     public AddFieldParameters(String title)
     {
         super(title);
         this.params = new JPanel();
         this.params.setLayout(new GridLayout(4, 2));
         this.identity = new Parameter(params, "Identity", "<identity>");
         this.type = new FieldTypeParameter(params, "Type");
         this.applicationCode =
             new Parameter(params, "Application code (byte)", "0");
         this.permissionCode =
             new Parameter(params, "Permission code (short)", "0");
         getContentPane().add(params);
         postInit();
     }
 
     /**
      * @return the value of the identity field
      */
     String getIdentity()
     {
         return this.identity.getValue();
     }
 
     /**
      * @return the value of the type field
      */
     String getType()
     {
         return this.type.getValue();
     }
 
     /**
      * @return the value of the application code field
      */
     String getApplicationCode()
     {
         return this.applicationCode.getValue();
     }
 
     /**
      * @return the value of the permission code field
      */
     String getPermissionCode()
     {
         return this.permissionCode.getValue();
     }
 }
 
 /**
  * Encapsulates parameters required to add a record
  * 
  * @author Ramon Servadei
  */
 class GetRecordParameters extends ParameterGatherer
 {
     private static final long serialVersionUID = 1L;
 
     final Parameter identity, type, domain;
 
     final JPanel params;
 
     public GetRecordParameters(String title)
     {
         super(title);
         this.params = new JPanel();
         this.params.setLayout(new GridLayout(3, 2));
         this.identity =
             new Parameter(params, "Identity", "<identity (or regex)>");
         this.type = new Parameter(params, "Type", "" + Type.RECORD.value());
         this.domain =
             new Parameter(params, "Domain", "" + Domain.FRAMEWORK.value());
         getContentPane().add(params);
         postInit();
     }
 
     /**
      * @return the value of the identity field
      */
     String getIdentity()
     {
         return this.identity.getValue();
     }
 
     /**
      * @return the value of the type field
      */
     String getType()
     {
         return this.type.getValue();
     }
 
     /**
      * @return the value of the domain field
      */
     String getDomain()
     {
         return this.domain.getValue();
     }
 }
 
 /**
  * Encapsulates getting parameters for subscribe/unsubscribe operations
  * 
  * @author Ramon Servadei
  */
 final class SubscribeRecordParameters extends GetRecordParameters
 {
     private static final long serialVersionUID = 1L;
 
     final Parameter contextIdentity;
 
     public SubscribeRecordParameters(String title)
     {
         super(title);
         super.params.setLayout(new GridLayout(4, 2));
         this.contextIdentity =
             new Parameter(params, "Context identity",
                 "<context name to subscribe from>");
         postInit();
     }
 
     String getContextIdentity()
     {
         return this.contextIdentity.getValue();
     }
 
     public static void main(String[] args)
     {
         final SubscribeRecordParameters subscribeRecordParameters =
             new SubscribeRecordParameters("test");
         subscribeRecordParameters.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
     }
 }