/*******************************************************************************
    * jhunters: Pool League
    * Copyright 2015 Tony Washer
    *
    * 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 net.sourceforge.jhunters.pool.ui;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.PrintWriter;
  import java.io.StringWriter;
  import java.time.Instant;
  import java.time.LocalDate;
  import java.time.LocalDateTime;
  import java.time.ZoneId;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Optional;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.w3c.dom.Document;
  import org.xml.sax.SAXException;
  
  import javafx.geometry.Bounds;
  import javafx.print.PageLayout;
  import javafx.print.PageOrientation;
  import javafx.print.Paper;
  import javafx.print.Printer;
  import javafx.print.PrinterJob;
  import javafx.scene.Node;
  import javafx.scene.control.Alert;
  import javafx.scene.control.Alert.AlertType;
  import javafx.scene.control.ButtonType;
  import javafx.scene.control.Label;
  import javafx.scene.control.TableColumn;
  import javafx.scene.control.TableView;
  import javafx.scene.control.TextArea;
  import javafx.scene.layout.GridPane;
  import javafx.scene.layout.Priority;
  import javafx.scene.transform.Scale;
  import javafx.scene.transform.Transform;
  import javafx.stage.FileChooser;
  import javafx.stage.FileChooser.ExtensionFilter;
  import javafx.stage.Stage;
  import net.sourceforge.jhunters.pool.PoolException;
  import net.sourceforge.jhunters.pool.data.Competition;
  import net.sourceforge.jhunters.pool.data.DataSet;
  import net.sourceforge.jhunters.pool.data.PlayerList;
  import net.sourceforge.jhunters.pool.data.XmlBuilder;
  import net.sourceforge.jhunters.pool.data.XmlParser;
  import net.sourceforge.jhunters.pool.ui.CompetitionPanel.ViewSelect;
  import net.sourceforge.jhunters.pool.ui.ReportPanel.TableSource;
  
  /**
   * Application Control.
   */
  public class AppControl {
      /**
       * The userHome property.
       */
      public static final String PROP_USERHOME = "user.home";
  
      /**
       * File Types Name.
       */
      public static final String EXT_POOL_NAME = GuiResource.FILETYPE_NAME.getValue();
  
      /**
       * File Types.
       */
      public static final String EXT_POOL = ".plxml";
  
      /**
       * File Types.
      */
     public static final String EXT_POOL_ALL = "*" + EXT_POOL;
 
     /**
      * File Types Name.
      */
     public static final String EXT_HTML_NAME = GuiResource.FILETYPE_NAME.getValue();
 
     /**
      * File Types.
      */
     public static final String EXT_HTML = ".html";
 
     /**
      * File Types.
      */
     public static final String EXT_HTML_ALL = "*" + EXT_HTML;
 
     /**
      * The row height.
      */
     private static final int ROW_HEIGHT = 20;
 
     /**
      * The number of initial players.
      */
     private static final int NUM_STARTING_PLAYERS = 5;
 
     /**
      * The application stage.
      */
     private final Stage theStage;
 
     /**
      * DocumentBuilder.
      */
     private final DocumentBuilder theBuilder;
 
     /**
      * Transformer.
      */
     private final Transformer theXformer;
 
     /**
      * The Tabs.
      */
     private MainTabView theTabs;
 
     /**
      * Report Panel.
      */
     private final ReportPanel theReportPanel;
 
     /**
      * Pool Preferences.
      */
     private PoolPreferences thePreferences;
 
     /**
      * Current dataSet.
      */
     private DataSet theDataSet;
 
     /**
      * Constructor.
      * @param pStage the stage
      * @throws PoolException on error
      */
     public AppControl(final Stage pStage) throws PoolException {
         /* protect against exceptions */
         try {
             /* Store the stage */
             theStage = pStage;
 
             /* Create an empty dataSet */
             theDataSet = new DataSet();
 
             /* Access preferences */
             thePreferences = new PoolPreferences();
 
             /* Create a Document builder */
             DocumentBuilderFactory myFactory = DocumentBuilderFactory.newInstance();
             theBuilder = myFactory.newDocumentBuilder();
 
             /* Create the transformer */
             TransformerFactory myXformFactory = TransformerFactory.newInstance();
             theXformer = myXformFactory.newTransformer();
 
             /* Create the reportPanel */
             theReportPanel = new ReportPanel(this);
 
         } catch (ParserConfigurationException | TransformerConfigurationException e) {
             throw new PoolException("Failed to initialise control", e);
         }
     }
 
     /**
      * Obtain the stage.
      * @return the stage
      */
     protected Stage getStage() {
         return theStage;
     }
 
     /**
      * Obtain the dataSet.
      * @return the dataSet
      */
     public DataSet getDataSet() {
         return theDataSet;
     }
 
     /**
      * Declare the tabs.
      * @param pTabs the tabs
      */
     protected void setTabs(final MainTabView pTabs) {
         theTabs = pTabs;
     }
 
     /**
      * Write DataSet to file.
      * @param pData the dataSet
      * @throws PoolException on error
      */
     public void writeDataSetToFile(final DataSet pData) throws PoolException {
         /* Access file name */
         File myFile = pData.getFileName();
 
         /* Protect the workbook access */
         try (FileOutputStream myOutFile = new FileOutputStream(myFile);
              BufferedOutputStream myStream = new BufferedOutputStream(myOutFile)) {
             /* Create a new document */
             Document myDocument = theBuilder.newDocument();
 
             /* Build the dataSet document */
             XmlBuilder myBuilder = new XmlBuilder(myDocument);
             myBuilder.buildDataSet(pData);
 
             /* Format the XML and write to stream */
             theXformer.transform(new DOMSource(myDocument), new StreamResult(myStream));
 
             /* Note that the data is now clean */
             pData.setUpdated(Boolean.FALSE);
             pData.setLastChange(LocalDate.now());
 
         } catch (TransformerException | IOException e) {
             throw new PoolException("Failed to transform XML", e);
         }
     }
 
     /**
      * Read DataSet from file.
      * @param pFile the input File
      * @return the dataSet
      * @throws PoolException on error
      */
     public DataSet readDataSetFromFile(final File pFile) throws PoolException {
         /* Protect the workbook access */
         try (FileInputStream myInFile = new FileInputStream(pFile);
              BufferedInputStream myStream = new BufferedInputStream(myInFile)) {
             /* Read the document from the stream and parse it */
             Document myDocument = theBuilder.parse(myStream);
 
             /* populate the list from the document */
             XmlParser myParser = new XmlParser(myDocument);
             DataSet myData = myParser.parseDataSet();
 
             /* Determine the update date of the file */
             long myModified = pFile.lastModified();
             Instant myf = Instant.ofEpochMilli(myModified);
             LocalDateTime myDateTime = LocalDateTime.ofInstant(myf, ZoneId.systemDefault());
             myData.setLastChange(myDateTime.toLocalDate());
             myData.setFileName(pFile);
 
             /* Return the data */
             return myData;
 
         } catch (IOException | SAXException e) {
             throw new PoolException("Failed to parse XML", e);
         }
     }
 
     /**
      * Adjust the stage.
      * @param pAdjust the adjustment
      */
     protected void adjustStage(final WindowAdjustment pAdjust) {
         /* Check the change in width */
         double myStageWidth = theStage.getWidth();
         myStageWidth += pAdjust.getWidth();
         myStageWidth = Math.max(myStageWidth, theStage.getMinWidth());
         theStage.setWidth(myStageWidth);
 
         /* Check the change in height */
         double myStageHeight = theStage.getHeight();
         myStageHeight += pAdjust.getHeight();
         myStageHeight = Math.max(myStageHeight, theStage.getMinHeight());
         theStage.setHeight(myStageHeight);
 
         /* Centre the application on the screen */
         theStage.centerOnScreen();
     }
 
     /**
      * Check for discard.
      * @return true/false
      */
     protected boolean checkDiscard() {
         /* If we have unsaved changes */
         if ((theDataSet != null)
             && theDataSet.isUpdated()) {
             /* Create a new alert */
             Alert myDialog = new Alert(AlertType.CONFIRMATION);
             myDialog.setTitle(GuiResource.DISCARD_DIALOG_TITLE.getValue());
             myDialog.setHeaderText(GuiResource.DISCARD_DIALOG_HEADING.getValue());
             myDialog.setContentText(GuiResource.DISCARD_DIALOG_MESSAGE.getValue());
 
             /* Show it */
             Optional<ButtonType> userChoice = myDialog.showAndWait();
 
             /* Signal whether to proceed with shutdown */
             return ButtonType.OK.equals(userChoice.get());
         }
 
         /* Allow shutdown */
         return true;
     }
 
     /**
      * Choose and load a file.
      */
     protected void chooseAndLoadFile() {
         /* check whether we should proceed */
         if (checkDiscard()) {
             /* Create the chooser */
             FileChooser myChooser = new FileChooser();
             myChooser.setTitle(GuiResource.SELECTFILE_DIALOG_TITLE.getValue());
             ExtensionFilter myFilter = new ExtensionFilter(EXT_POOL_NAME, EXT_POOL_ALL);
             myChooser.getExtensionFilters().add(myFilter);
 
             /* If we have an existing dataSet */
             File myFile = theDataSet.getFileName();
             if (myFile != null) {
                 /* If the file is not a directory */
                 if (!myFile.isDirectory()) {
                     /* Set as initial directory */
                     myFile = myFile.getParentFile();
                 }
 
                 /* Set the correct directory */
                 myChooser.setInitialDirectory(myFile);
 
                 /* Else just start in the home directory */
             } else {
                 myChooser.setInitialDirectory(new File(System.getProperty(PROP_USERHOME)));
             }
 
             /* Allow user to choose item */
             myFile = myChooser.showOpenDialog(theStage);
             if (myFile != null) {
                 /* Load dataFile */
                 loadDataFile(myFile);
             }
         }
     }
 
     /**
      * Load DefaultData.
      */
     protected void loadDefaultData() {
         /* Access file name */
         File myFile = thePreferences.getFileName();
 
         /* If we have a fileName */
         if (myFile != null) {
             /* Load the data */
             loadDataFile(myFile);
 
             /* else no data */
         } else {
             createNewData();
         }
     }
 
     /**
      * Load Data from named file.
      * @param pFile the dataFile to load
      */
     protected void loadDataFile(final File pFile) {
         /* Protect against exceptions */
         try {
             /* Load the data from the file */
             loadTheDataFile(pFile);
 
             /* Handle exceptions */
         } catch (PoolException e) {
             /* Report exception to user */
             reportException("Failed to load data", e);
         }
     }
 
     /**
      * Load Data from named file.
      * @param pFile the dataFile to load
      * @throws PoolException on error
      */
     protected void loadTheDataFile(final File pFile) throws PoolException {
         /* Load the data from the file */
         theDataSet = readDataSetFromFile(pFile);
 
         /* Declare the dataSet */
         theTabs.setData(theDataSet);
 
         /* Note the name in preferences */
         thePreferences.setFileName(pFile);
     }
 
     /**
      * Create new dataSet.
      */
     protected void createNewData() {
         /* check whether we should proceed */
         if (checkDiscard()) {
             /* Create new dataFile */
             theDataSet = new DataSet();
 
             /* Create sample players */
             PlayerList myPlayers = theDataSet.getPlayers();
             for (int i = 0; i < NUM_STARTING_PLAYERS; i++) {
                 myPlayers.createUniquePlayer();
             }
 
             /* Set the data */
             theTabs.setData(theDataSet);
         }
     }
 
     /**
      * Save the data to the named file.
      */
     protected void saveToFile() {
         /* If the dataSet does not have a linked file */
         File myFile = theDataSet.getFileName();
         if (myFile == null || myFile.isDirectory()) {
             /* Handle as saveAsFile() */
             saveAsFile();
         } else {
             /* Protect against exceptions */
             try {
                 /* Write the data to File */
                 writeDataSetToFile(theDataSet);
 
                 /* Note the name in preferences */
                 thePreferences.setFileName(myFile);
 
                 /* Handle exceptions */
             } catch (PoolException e) {
                 /* Report exception to user */
                 reportException("Failed to save data", e);
             }
         }
     }
 
     /**
      * Save the data to a userSpecified file.
      */
     protected void saveAsFile() {
         /* Create the chooser */
         FileChooser myChooser = new FileChooser();
         myChooser.setTitle(GuiResource.SAVEASFILE_DIALOG_TITLE.getValue());
         ExtensionFilter myFilter = new ExtensionFilter(EXT_POOL_NAME, EXT_POOL_ALL);
         myChooser.getExtensionFilters().add(myFilter);
 
         /* If the dataSet has a linked file */
         File myFile = theDataSet.getFileName();
         if (myFile != null) {
             /* If the file is a directory */
             if (myFile.isDirectory()) {
                 /* Set as initial directory */
                 myChooser.setInitialDirectory(myFile);
 
                 /* else split into directory and file */
             } else {
                 /* Set the correct directory */
                 File myDir = myFile.getParentFile();
                 myChooser.setInitialDirectory(myDir);
 
                 /* Set the name as the initial name */
                 myChooser.setInitialFileName(myFile.getName());
             }
 
             /* Else just start in the home directory */
         } else {
             myChooser.setInitialDirectory(new File(System.getProperty(PROP_USERHOME)));
         }
 
         /* Show the dialog */
         myFile = myChooser.showSaveDialog(theStage);
         if (myFile != null) {
             /* Save the file to the name */
             theDataSet.setFileName(myFile);
             theDataSet.setUpdated(Boolean.TRUE);
             saveToFile();
         }
     }
 
     /**
      * Report exception.
      * @param pMessage the message
      * @param pException the exception
      */
     protected void reportException(final String pMessage,
                                    final PoolException pException) {
         /* Create the alert dialog */
         Alert myAlert = new Alert(AlertType.ERROR);
         myAlert.setTitle(GuiResource.ERROR_DIALOG_TITLE.getValue());
         myAlert.setHeaderText(null);
         myAlert.setContentText(pMessage);
 
         /* Obtain print-out of Exception */
         StringWriter mySWriter = new StringWriter();
         PrintWriter myPWriter = new PrintWriter(mySWriter);
         pException.printStackTrace(myPWriter);
         String myExceptionText = mySWriter.toString();
 
         /* Create Exception pane */
         Label myLabel = new Label(GuiResource.ERROR_DIALOG_STACK.getValue());
         TextArea myTextArea = new TextArea(myExceptionText);
         myTextArea.setEditable(false);
         myTextArea.setWrapText(true);
 
         myTextArea.setMaxWidth(Double.MAX_VALUE);
         myTextArea.setMaxHeight(Double.MAX_VALUE);
         GridPane.setVgrow(myTextArea, Priority.ALWAYS);
         GridPane.setHgrow(myTextArea, Priority.ALWAYS);
 
         /* Add the Exception pane as expandable content */
         GridPane myXtraContent = new GridPane();
         myXtraContent.setMaxWidth(Double.MAX_VALUE);
         myXtraContent.add(myLabel, 0, 0);
         myXtraContent.add(myTextArea, 0, 1);
         myAlert.getDialogPane().setExpandableContent(myXtraContent);
 
         /* Display the alert */
         myAlert.showAndWait();
     }
 
     /**
      * Print the relevant node.
      * @param pNode the node to print
      * @param pSelect the view selection
      */
     protected void printNode(final Node pNode,
                              final ViewSelect pSelect) {
         /* Determine page orientation */
         PageOrientation myOrientation = pSelect.getOrientation();
 
         /* If the node is a table source */
         if (pNode instanceof TableSource) {
             /* Create and print report */
             theReportPanel.printReport((TableSource) pNode, myOrientation);
 
             /* Print out as a resized node */
         } else {
             printNode(pNode, myOrientation);
         }
     }
 
     /**
      * Source the relevant node.
      * @param pNode the node to print
      * @param pSelect the view selection
      */
     protected void sourceNode(final Node pNode,
                               final ViewSelect pSelect) {
         /* If the node is a table source */
         if (pNode instanceof TableSource) {
             /* Create the chooser */
             FileChooser myChooser = new FileChooser();
             myChooser.setTitle(GuiResource.SAVEASFILE_DIALOG_TITLE.getValue());
             ExtensionFilter myFilter = new ExtensionFilter(EXT_HTML_NAME, EXT_HTML_ALL);
             myChooser.getExtensionFilters().add(myFilter);
 
             /* Write to home directory */
             myChooser.setInitialDirectory(new File(System.getProperty(PROP_USERHOME)));
 
             /* Set the name as the initial name */
             myChooser.setInitialFileName(pSelect.toString() + EXT_HTML);
 
             /* Show the dialog */
             File myFile = myChooser.showSaveDialog(theStage);
             if (myFile != null) {
                 /* Create and output source report */
                 theReportPanel.sourceReport((TableSource) pNode, myFile);
             }
         }
     }
 
     /**
      * Create the WebSite.
      * @param pMaster the master competition panel
      * @param pCompetition the competition
      */
     protected void createWeb(final CompetitionPanel pMaster,
                              final Competition pCompetition) {
         /* Create and output webSite */
         theReportPanel.createWeb(pMaster, pCompetition);
     }
 
     /**
      * Print the relevant node.
      * @param pNode the node to print
      * @param pOrientation the report orientation
      */
     protected void printNode(final Node pNode,
                              final PageOrientation pOrientation) {
         /* Create a new printer job */
         PrinterJob job = PrinterJob.createPrinterJob();
 
         /* Select printer, allowing for cancel */
         if ((job != null)
             && job.showPrintDialog(theStage)) {
             /* Stop the mouse affecting the node */
             pNode.setMouseTransparent(true);
 
             /* Save existing transforms */
             Bounds myBounds = pNode.getBoundsInParent();
             List<Transform> myTransforms = pNode.getTransforms();
             List<Transform> oldTransforms = new ArrayList<Transform>(myTransforms);
 
             /* Access printer and determine orientation */
             Printer myPrinter = job.getPrinter();
 
             /* Create page layout of correct type */
             PageLayout myLayout = myPrinter.createPageLayout(Paper.A4, pOrientation, Printer.MarginType.DEFAULT);
 
             /* Scale the node to fit the page */
             double scaleX = myLayout.getPrintableWidth() / myBounds.getWidth();
             double scaleY = PageOrientation.LANDSCAPE.equals(pOrientation)
                                                                            ? myLayout.getPrintableHeight() / myBounds.getHeight()
                                                                            : 1.0f;
             myTransforms.add(new Scale(scaleX, scaleY));
 
             /* Print the page */
             boolean success = job.printPage(myLayout, pNode);
             if (success) {
                 job.endJob();
             }
 
             /* restore original transformations */
             myTransforms.clear();
             myTransforms.addAll(oldTransforms);
 
             /* Re-enable the mouse */
             pNode.setMouseTransparent(false);
         }
     }
 
     /**
      * Window adjustment.
      */
     protected static final class WindowAdjustment {
         /**
          * Width.
          */
         private final double theWidth;
 
         /**
          * Height.
          */
         private final double theHeight;
 
         /**
          * Constructor.
          * @param <T> the table data type
          * @param pTable the new table
          * @param pCurrent the current node
          */
         protected <T> WindowAdjustment(final TableView<T> pTable,
                                        final Node pCurrent) {
             /* Access current bounds */
             Bounds myBounds = pCurrent.layoutBoundsProperty().getValue();
 
             /* Determine width adjustment */
             double myTableWidth = calculateTableWidth(pTable);
             theWidth = myTableWidth - myBounds.getMaxX();
 
             /* Determine height adjustment */
             double myTableHeight = calculateTableHeight(pTable);
             theHeight = myTableHeight - myBounds.getMaxY();
         }
 
         /**
          * Obtain width.
          * @return the width adjustment
          */
         public double getWidth() {
             return theWidth;
         }
 
         /**
          * Obtain height.
          * @return the height adjustment
          */
         public double getHeight() {
             return theHeight;
         }
 
         /**
          * Calculate the full table width.
          * @param pTable the table to calculate
          * @param <T> the data type of the table
          * @return the full width
          */
         private static <T> double calculateTableWidth(final TableView<T> pTable) {
             /* Define width variable */
             double myWidth = 2;
 
             /* Loop through the columns */
             Iterator<TableColumn<T, ?>> myIterator = pTable.getColumns().iterator();
             while (myIterator.hasNext()) {
                 TableColumn<T, ?> myCol = myIterator.next();
 
                 /* Add column width */
                 myWidth += myCol.getMinWidth();
             }
 
             /* return the width */
             return myWidth;
         }
 
         /**
          * Determine the full table height.
          * @param pTable the table to calculate
          * @param <T> the data type of the table
          * @return the full height
          */
         private static <T> double calculateTableHeight(final TableView<T> pTable) {
             /* Height = row height * (#rows +2) */
             int myNumRows = pTable.getItems().size() + 2;
             int myRowHeight = ROW_HEIGHT;
             return (double) (myRowHeight * myNumRows);
         }
     }
 }