package org.whatsitcalled.webflange.webapp;
   
   import java.io.IOException;
   import java.io.InputStream;
   import java.util.List;
   
   import org.apache.commons.io.IOUtils;
   import org.apache.log4j.Logger;
   import org.apache.wicket.AttributeModifier;
  import org.apache.wicket.Page;
  import org.apache.wicket.PageParameters;
  import org.apache.wicket.ajax.AjaxRequestTarget;
  import org.apache.wicket.ajax.markup.html.AjaxLink;
  import org.apache.wicket.behavior.SimpleAttributeModifier;
  import org.apache.wicket.extensions.ajax.markup.html.modal.ModalWindow;
  import org.apache.wicket.markup.html.basic.Label;
  import org.apache.wicket.markup.html.form.ChoiceRenderer;
  import org.apache.wicket.markup.html.form.DropDownChoice;
  import org.apache.wicket.markup.html.form.Form;
  import org.apache.wicket.markup.html.form.RequiredTextField;
  import org.apache.wicket.markup.html.form.TextArea;
  import org.apache.wicket.markup.html.form.TextField;
  import org.apache.wicket.markup.html.link.BookmarkablePageLink;
  import org.apache.wicket.markup.html.link.Link;
  import org.apache.wicket.markup.html.panel.Panel;
  import org.apache.wicket.markup.repeater.Item;
  import org.apache.wicket.markup.repeater.data.DataView;
  import org.apache.wicket.markup.repeater.data.IDataProvider;
  import org.apache.wicket.model.AbstractReadOnlyModel;
  import org.apache.wicket.model.CompoundPropertyModel;
  import org.apache.wicket.model.IModel;
  import org.apache.wicket.model.Model;
  import org.apache.wicket.model.PropertyModel;
  import org.whatsitcalled.webflange.ResourceFactory;
  import org.whatsitcalled.webflange.model.LoadTest;
  import org.whatsitcalled.webflange.model.LoadTestDAO;
  import org.whatsitcalled.webflange.model.ProjectDAO;
  import org.whatsitcalled.webflange.model.Script;
  import org.whatsitcalled.webflange.model.ScriptDAO;
  import org.whatsitcalled.webflange.service.LoadTestRunningException;
  import org.whatsitcalled.webflange.webapp.model.LoadTestDataProvider;
  
  public class TestPanel extends Panel {
  	AddTestForm testForm;
  
  	private static final Logger LOGGER = Logger.getLogger(TestPanel.class);
  
  	public TestPanel(String id) {
  		super(id);
  		// Add the test list
  		add(new Link("newTest") {
  			public void onClick() {
  				testForm.setVisible(true);
  				setTest(getNewLoadTest());
  			}
  		});
  
  		add(new TestDataView("tests", new LoadTestDataProvider()));
  
  		// add the Test Form
  		testForm = new AddTestForm("addTestForm", new CompoundPropertyModel(
  				getTest()));
  		testForm.setVisible(false);
  		add(testForm);
  	}
  
  	private LoadTest getTest() {
  		LoadTest test = (LoadTest) getModelObject();
  		if (test == null) {
  			test = getNewLoadTest();
  			setTest(test);
  		}
  		return test;
  	}
  
  	private void setTest(LoadTest test) {
  		setModel(new CompoundPropertyModel(test));
  	}
  
  	public void onModelChanged() {
  		if ((testForm != null) && this.getModel() != null) {
  			testForm.setModel(this.getModel());
  		}
  	}
  
  	public static final LoadTest getLoadTestForEditing(LoadTest test) {
  		LoadTest loadTest = ResourceFactory.getLoadTestDAO().getLoadTest(test.getId());
  		loadTest.setEnabled(false);
  		ResourceFactory.getLoadTestDAO().saveLoadTest(loadTest);
  		
  		return loadTest;
  	}
  	
  	//TODO Need a RUNNING column, and auto refresh if not editing
  	protected final class TestDataView extends DataView {
  		protected TestDataView(String arg0, IDataProvider arg1) {
  			super(arg0, arg1);
  		}
  
 		protected void populateItem(final Item item) {
 			final LoadTest test = (LoadTest) item.getModelObject();
 			
 			//Edit function
 			item.add(new Link("edit") {
 				public void onClick() {
 					testForm.setVisible(true);
 					LoadTest test = (LoadTest) getParent().getModelObject();
 					setTest(getLoadTestForEditing(test));
 					// refreshTests();
 				}
 			});
 			
 			//Enable/Diable function
 			Link enableLink = new Link("enable") {
 				public void onClick() {
 					LoadTest test = (LoadTest) getParent().getModelObject();
 					if (test.getEnabled()) {
 						LOGGER.debug("Disabling LoadTest: " + test.getName());
 						test.setEnabled(false);
 					} else {
 						LOGGER.debug("Enabling LoadTest: " + test.getName());
 						test.setEnabled(true);
 					}
 					ResourceFactory.getLoadTestDAO().saveLoadTest(test);
 				}
 			};
 			enableLink.add(new Label("enable/disable", new Model() {
 				public Object getObject() {
 					return test.getEnabled() ? "disable" : "enable";
 				}
 			}));
 			item.add(enableLink);
 
 			//Delete Function
 			Link deleteLink = new Link("delete") {
 				public void onClick() {
 					LoadTest test = (LoadTest) getParent().getModelObject();
 					try {
 						ResourceFactory.getLoadTestService().removeLoadTest(test.getId());
 					} catch (LoadTestRunningException e) {
 						LOGGER.error("Unable to delete test.");
 						error(test.getName() + " is enabled or running and cannot be deleted!");
 					}
 				}
 			};
 			deleteLink.add(new SimpleAttributeModifier(
 				      "onclick", "return confirm('Delete test " + test.getName() + "?');"));
 			
 			item.add(deleteLink);
 			
 			//Run now function
 			Link runLink = new Link("runNow") {
 				public void onClick() {
 					LoadTest test = (LoadTest) getParent().getModelObject();
 					ResourceFactory.getGrinderTestRunner().runAsThread(test);
 				}
 			};
 			runLink.add(new SimpleAttributeModifier(
 				      "onclick", "return confirm('Run test " + test.getName() + "?');"));
 			item.add(runLink);
 
 			//Reports link
 			item.add(new BookmarkablePageLink("results", HomePage.class, new PageParameters("testId=" + test.getId())));
 			
 			item.add(new Label("project", test.getProjectName()));
 			item.add(new Label("test", test.getName()));
 			item.add(new Label("script", test.getScriptName()));
 			item.add(new Label("frequency", test.getFrequency()));
 
 			item.add(new AttributeModifier("class", true,
 					new AbstractReadOnlyModel() {
 						public Object getObject() {
 							return (item.getIndex() % 2 == 1) ? "even" : "odd";
 						}
 					}));
 		}
 	}
 
 	protected final class AddTestForm extends Form {
 		/**
 		 * Constructor
 		 * 
 		 * @param id
 		 *            The name of this component
 		 */
 		public AddTestForm(final String id, IModel model) {
 			// Check if we have a LoadTest in the parents modelobject
 			// Construct form with no validation listener
 			super(id, model);
 			add(getProjectChooser());
 			add(new RequiredTextField("name"));
 			addScriptView();
 			add(getScriptChooser());
 			TextField cronTextField = new TextField("frequency");
 			//cronTextField.setRequired(true);
 			cronTextField.add(new CronValidator("Invalid cron expression in Frequency field."));
 			add(cronTextField);
 			add(new Label("contextVars", getContextVars()));
 			add(new TextArea("properties"));
 			add(new TextArea("description"));
 
 			final ModalWindow cronHelp;
 			add(cronHelp = new ModalWindow("cronHelp"));
 
 			cronHelp.setContent(new CronHelpPanel(cronHelp.getContentId()));
 			cronHelp.setTitle("Cron Expressions");
 			cronHelp.setCookieName("cronHelp");
 
 			add(new AjaxLink("showCronHelp") {
 				public void onClick(AjaxRequestTarget target) {
 					cronHelp.show(target);
 				}
 			});
 
 		}
 
 		private void addScriptView() {
 			// View Script Modal Window stuff
 			final ModalWindow viewScript = new ModalWindow("viewScript");
 
 			add(viewScript);
 
 			add(new AjaxLink("showScript") {
 				public void onClick(AjaxRequestTarget target) {
 					final Script script = getTest().getScript();
 					viewScript.setTitle(script.getName());
 					viewScript.setCookieName("viewScript");
 					viewScript.setPageMapName("viewScript");
 
 					viewScript.setPageCreator(new ModalWindow.PageCreator() {
 						public Page createPage() {
 							return new ScriptViewPage(script, viewScript);
 						}
 					});
 					viewScript.show(target);
 				}
 			});			
 		}
 
 		private DropDownChoice getProjectChooser() {
 			ProjectDAO dao = ResourceFactory.getProjectDAO();
 			List projects = dao.getProjects();
 			DropDownChoice ddc = new DropDownChoice("project",
 					new PropertyModel(getModelObject(), "project"), projects,
 					new ChoiceRenderer("name", "id"));
 			ddc.add(new ChoiceRequiredValidator("You must select a project."));
 			return ddc;
 		}
 
 		private DropDownChoice getScriptChooser() {
 			ScriptDAO dao = ResourceFactory.getScriptDAO();
 			List scripts = dao.getScripts();
 			DropDownChoice ddc = new DropDownChoice("script",
 					new PropertyModel(getModelObject(), "script"), scripts,
 					new ChoiceRenderer("name", "id"));
 			ddc.add(new ChoiceRequiredValidator("You must select a script."));
 			return ddc;
 		}
 
 		/**
 		 * Show the resulting valid edit
 		 */
 		public final void onSubmit() {
 			final LoadTest test = (LoadTest) getModelObject();
 			LoadTestDAO dao = ResourceFactory.getLoadTestDAO();
 			dao.saveLoadTest(test);
 			this.setModel(new CompoundPropertyModel(getNewLoadTest()));
 			this.setVisible(false);
 
 		}
 
 		@Override
 		protected void onModelChanged() {
 			super.onModelChanged();
 			// Dropdown choice acts funny unless we remove it and add it back
 			
 			remove("project");
 			add(getProjectChooser());
 			remove("script");
 			add(getScriptChooser());
 		}
 		
 		private String getContextVars() {
 			List<String> vars = ResourceFactory.getGrinderTestRunner().getContextVars();
 			StringBuffer buf = new StringBuffer();
 			for(String var:vars) {
 				buf.append("${");
 				buf.append(var);
 				buf.append("}\n");
 			}
 			//TODO It would be great to have a module for context variables that has defaults configured via spring, but allows other vars to be set at a global level
 			
 			return buf.toString();
 		}
 	}
 
 	protected class CronHelpPanel extends Panel {
 
 		public CronHelpPanel(String arg0) {
 			super(arg0);
 			// TODO Auto-generated constructor stub
 		}
 	}
 	
 	LoadTest getNewLoadTest() {
 			return ResourceFactory.getLoadTestService().createLoadTest();
 	}
 	
 }