/*
    * Copyright 2013-2023 Medical Information Systems Research Group (https://medical.zcu.cz),
    * Department of Computer Science and Engineering, University of West Bohemia.
    * Address: Univerzitni 8, 306 14 Plzen, Czech Republic.
    *
    * This file is part of Sparkle project.
    *
    * Sparkle 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, either version 3 of the License.
   *
   * Sparkle 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 Sparkle. If not, see <http://www.gnu.org/licenses/>.
   */
  package cz.zcu.mre.sparkle.gui.mainForm.mainTabPane;
  
  import cz.zcu.mre.sparkle.Messages;
  import cz.zcu.mre.sparkle.data.Storage;
  import cz.zcu.mre.sparkle.gui.dialogs.other.ProgressDialog;
  import cz.zcu.mre.sparkle.gui.evaluation.EvaluationTab;
  import cz.zcu.mre.sparkle.gui.evaluation.queryTabs.select.SelectEvaluationTab;
  import cz.zcu.mre.sparkle.gui.mainForm.MainForm;
  import cz.zcu.mre.sparkle.gui.query.QueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.QueryTab;
  import cz.zcu.mre.sparkle.gui.query.QueryTabPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.insert.InsertQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.insert.InsertQueryTab;
  import cz.zcu.mre.sparkle.gui.query.other.CloseableTab;
  import cz.zcu.mre.sparkle.gui.query.other.SaverTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.ask.AskQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.ask.AskQueryTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.construct.ConstructQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.construct.ConstructQueryTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.delete.DeleteInsertQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.delete.DeleteInsertQueryTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.delete.DeleteQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.delete.DeleteQueryTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.describe.DescribeQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.describe.DescribeQueryTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.select.SelectQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.select.SelectQueryTab;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.subselect.SubSelectPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.subselect.SubSelectQueryFormPane;
  import cz.zcu.mre.sparkle.gui.query.queryTypes.subselect.SubSelectQueryTab;
  import javafx.collections.ObservableList;
  import javafx.concurrent.Task;
  import javafx.event.Event;
  import javafx.event.EventHandler;
  import javafx.scene.control.Tab;
  import javafx.scene.control.TabPane;
  import org.reactfx.collection.LiveArrayList;
  import java.io.File;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Queue;
  import java.util.concurrent.ExecutionException;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  import static cz.zcu.mre.sparkle.tools.Definitions.QUERY_FILE_EXTENSION_DELIMITER;
  
  /**
   * Kontroler {@code TabPane} pro zalozky s dotazy nebo vysledkem dotazu.
   *
   * @author Jan Smucr
   * @author Klara Hlavacova
   * @author Petr Vcelak (vcelak@kiv.zcu.cz)
   */
  public class MainTabPane extends TabPane {
  
      private static final Logger LOG = Logger.getLogger(MainForm.class.getName());
  
      public enum QueryType {
          SELECT, ASK, DESCRIBE, CONSTRUCT, DELETE, INSERT, DELETE_INSERT, SUBSELECT
      }
  
      /**
       * Akce pri uzavreni aplikace - zavreni zalozek.
       *
       * @param mainForm okno (hlavni formular)
       *
       * @return false - chyba, true - ok
       */
      public final boolean onCloseRequest(MainForm mainForm) {
          ObservableList<Tab> tabs = new LiveArrayList<>(getTabs());
          tabs.forEach((tab) -> {
              QueryTabPane.selectFormTab(tab);
          });
  
          // Postupné uzavření záložek. Každá záložka může vyvolat dialog tázající-se na uložení souboru.
          final Iterator<Tab> iter = getTabs().iterator();
  
          while (iter.hasNext()) {
              final Tab tab = iter.next();
 
             if (tab instanceof CloseableTab && !(tab instanceof SubSelectQueryTab)) {
                 if (!((CloseableTab) tab).requestClose()) {
                     return false;
                 }
             }
             if (mainForm.getMainTabPane().getTabs().contains(tab)) {
                 iter.remove();
             }
         }
 
         saveAndDisconnect(mainForm);
         return true;
     }
 
     /**
      * Ulozi nastaveni (lokalni zdroje, ...) a odpoji uloziste.
      *
      * @param mainForm okno (hlavní formular)
      */
     private void saveAndDisconnect(MainForm mainForm) {
         try {
             ProgressDialog.performTask(mainForm.getStage(), new Task<Void>() {
                 @Override
                 protected Void call() throws Exception {
                     updateMessage(Messages.getString("SAVING_CONFIGURATION")); //$NON-NLS-1$
                     mainForm.storeObjects();
                     mainForm.saveFormSettings();
                     updateMessage(Messages.getString("DISCONNECTING")); //$NON-NLS-1$
                     mainForm.disconnect();
                     return null;
                 }
             });
         } catch (InterruptedException | ExecutionException e) {
             LOG.log(Level.SEVERE, "Exception: ", e); //$NON-NLS-2$
         }
     }
 
     /**
      * Vlozi zalozku.
      *
      * @param tab vkladana zalozka
      */
     private void addTab(final Tab tab) {
         getTabs().add(tab);
     }
 
     /**
      * Vrati aktivni {@link QueryTab} nebo <code>null</code>.
      *
      * @return Aktivní {@link QueryTab} nebo <code>null</code>.
      */
     public QueryTab<?> getCurrentQueryTab() {
         final Tab tab = getSelectionModel().getSelectedItem();
         return tab instanceof QueryTab<?> ? (QueryTab<?>) tab : null;
     }
 
     /**
      * Method shows relevant tab.
      *
      * @param tab Relevant tab.
      */
     public void showTab(Tab tab) {
         getSelectionModel().select(tab);
     }
 
     /**
      * Vrací {@link QueryFormPane} vázaný na aktivní {@link QueryTab} nebo
      * {@link EvaluationTab}.
      *
      * @return Instance {@link QueryFormPane}.
      */
     public QueryFormPane<?> getCurrentQueryPane() {
         QueryTab<?> tab = getCurrentQueryTab();
         if (tab == null) {
             final EvaluationTab<?> evTab = getCurrentEvaluationTab();
             if (evTab == null) {
                 return null;
             }
             tab = evTab.getQueryTab();
         }
         return tab.getQueryFormPane();
     }
 
     /**
      * @return Aktivní {@link EvaluationTab} nebo <code>null</code>.
      */
     private EvaluationTab<?> getCurrentEvaluationTab() {
         final Tab tab = getSelectionModel().getSelectedItem();
         return tab instanceof EvaluationTab<?> ? (EvaluationTab<?>) tab : null;
     }
 
     /**
      * It returns relevant {@link QueryTab} due to parameter
      * ({@link QueryFormPane}).
      *
      * @param queryFormPane {@link QueryFormPane} of wanted {@link QueryTab}.
      *
      * @return Relevant {@link QueryTab}.
      */
     public QueryTab getQueryTab(QueryFormPane queryFormPane) {
         for (Tab tab : getTabs()) {
             if (!(tab instanceof SelectEvaluationTab)) {
                 QueryTab qt = (QueryTab) tab;
                 if (qt.getQueryFormPane() == queryFormPane) {
                     return qt;
                 }
             }
         }
         return null;
     }
 
     /**
      * Vrati {@code QueryFormPane} rodicovske zalozky subselektu.
      *
      * @param queryTab subselekt zalozka
      *
      * @return {@code QueryFormPane} rodicovske zalozky subselektu
      */
     public static QueryFormPane<?> getMainQueryPart(SubSelectQueryTab queryTab) {
         QueryFormPane<?> queryFormPane = null;
         SubSelectQueryFormPane subSelectQueryPane = (SubSelectQueryFormPane) queryTab.getQueryFormPane();
 
         while (queryFormPane == null) {
             QueryFormPane<?> parentQueryFormPane = subSelectQueryPane.getSubSelectPane().getParentQueryFormPane();
 
             if (parentQueryFormPane instanceof SubSelectQueryFormPane) {
                 subSelectQueryPane = (SubSelectQueryFormPane) parentQueryFormPane;
             } else {
                 queryFormPane = parentQueryFormPane;
             }
         }
 
         return queryFormPane;
     }
 
     /**
      * Nacte dotaz ze souboru
      *
      * @param file soubor s dotazem (.sqf, .txt)
      * @param mainForm The main form.
      */
     public static final void open(final File file, MainForm mainForm) {
 
         for (final Tab tab : mainForm.getMainTabPane().getTabs()) {
             if (!(tab instanceof SaverTab)) {
                 continue;
             }
             final File openedFile = ((SaverTab) tab).fileProperty().get();
 
             if (file.equals(openedFile)) {
                 if (!((CloseableTab) tab).requestClose()) {
                     return;
                 }
                 closeTab(tab, mainForm);
                 //mainTabPane.getSelectionModel().select(tab);
                 break;
             }
         }
 
         Storage storage
                 = new Storage(mainForm.getAppPrefixesStorage(), mainForm.getAppResourcesStorage(),
                         mainForm.getAppDataTypesStorage(), mainForm.getAppFunctionsStorage());
 
         int countTabBeforeLoading = mainForm.getMainTabPane().getTabs().size();
         final Tab tab = QueryTab.open(mainForm, file, mainForm.getStage(), mainForm.getDataAgent(), storage);
 
         int countTabAfterLoading = mainForm.getMainTabPane().getTabs().size();
         int positionOfMainQueryPart = countTabAfterLoading - (countTabAfterLoading - countTabBeforeLoading);
 
         if (tab != null) { // Reordering of positions of loaded query and its SUBSELECTs.
             mainForm.getMainTabPane().getTabs().add(positionOfMainQueryPart, tab);
             mainForm.getMainTabPane().getSelectionModel().select(tab);
             setSubQueriesDefaultState(tab, mainForm);
         } else { // Removing of SubSelectQueryTabs - if loading failed
             for (int i = positionOfMainQueryPart; i < countTabAfterLoading; i++) {
                 mainForm.getMainTabPane().getTabs().remove(positionOfMainQueryPart);
             }
         }
     }
 
     /**
      * Zavre zalozku.
      *
      * @param tab Zavirana zalozka
      * @param mainForm okno (hlavni formular)
      */
     public static void closeTab(Tab tab, MainForm mainForm) {
         EventHandler<Event> handler = tab.getOnClosed();
         if (null != handler) {
             handler.handle(null);
         } else {
 
             try {
                 mainForm.getMainTabPane().getTabs().remove(tab);
 
             } catch (Exception e) {
                 LOG.info(e.getMessage());
             }
         }
     }
 
     /**
      * Method creates binding between "main query part" (e.g. SELECT query) and
      * SUBSELECT. It's used during auto-loading query from text file.
      *
      * @param mainQueryTab Main query tab (e.g. SELECT query).
      * @param mainForm The main form.
      */
     public static void setSubQueriesDefaultState(Tab mainQueryTab, MainForm mainForm) {
 
         if (mainQueryTab instanceof QueryTab) {
             QueryTab queryTabMainQuery = (QueryTab) mainQueryTab;
 
             Queue<QueryTab> nodeQueue = new LinkedList<>();
             String subSelectSuffix = Messages.getString("SUBSELECT_QUERY_DEFAULT_FILE_NAME"); //$NON-NLS-1$
             nodeQueue.add(queryTabMainQuery);
 
             while (!nodeQueue.isEmpty()) {
                 QueryTab<?> currentQueryTab = nodeQueue.remove();
 
                 mainForm.getContextMenu(currentQueryTab);
 
                 String queryTabName;
                 if (currentQueryTab.getQueryFormPane() instanceof SubSelectQueryFormPane) {
                     queryTabName = currentQueryTab.titleProperty().get();
 
                     // Binding changed properties
                     currentQueryTab.setCheckingMainQueryPart(queryTabMainQuery.getFormChangedProperty());
                     queryTabMainQuery.setCheckingSubSelect(currentQueryTab.getFormChangedProperty());
                 } else {
                     String name = queryTabMainQuery.titleProperty().get();
                     queryTabName = name.substring(0, name.lastIndexOf(QUERY_FILE_EXTENSION_DELIMITER));
                 }
 
                 int counter = 1;
                 List<SubSelectPane> subSelectPanes = currentQueryTab.getQueryFormPane().getSubSelectPanes();
 
                 for (SubSelectPane subSelectPane : subSelectPanes) {
                     subSelectPane.setQueryTabName(queryTabMainQuery, queryTabName + subSelectSuffix + counter);
                     nodeQueue.add(subSelectPane.getParentQueryTab());
                     counter++;
                 }
             }
         }
 
         /*final Color color = queryTabMainQuery.getQueryFormPane().getObtainedColor();
         if (color != null) {
             queryTabMainQuery.setBackgroundColor(color);
         }*/
         mainForm.setLoading(false);
     }
 
     /**
      * Vrati zalozku s danym typem dotazu.
      *
      * @param type typ dotazu
      * @param mainForm okno (hlavni formular)
      * @return Return the created Tab.
      */
     public Tab createQueryTab(QueryType type, MainForm mainForm) {
         Storage localStorage = new Storage(mainForm.getAppPrefixesStorage(), mainForm.getAppResourcesStorage(),
                 mainForm.getAppDataTypesStorage(), mainForm.getAppFunctionsStorage());
         final Tab tab;
         switch (type) {
 
             case SELECT:
                 tab = new SelectQueryTab(new SelectQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                         SelectQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case ASK:
                 tab = new AskQueryTab(new AskQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                         AskQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case DESCRIBE:
                 tab = new DescribeQueryTab(new DescribeQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                         DescribeQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case CONSTRUCT:
                 tab = new ConstructQueryTab(
                         new ConstructQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                                 ConstructQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case DELETE_INSERT:
                 tab = new DeleteInsertQueryTab(
                         new DeleteInsertQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                                 DeleteInsertQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case INSERT:
                 tab = new InsertQueryTab(new InsertQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                         InsertQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case DELETE:
                 tab = new DeleteQueryTab(new DeleteQueryFormPane(mainForm, mainForm.getDataAgent(), localStorage,
                         DeleteQueryFormPane.XML_QUERY_TYPE_VALUE));
                 addAndSelectTab(tab);
                 return tab;
 
             case SUBSELECT:
                 tab = new SubSelectQueryTab(new SubSelectQueryFormPane(mainForm, mainForm.getDataAgent(),
                         localStorage, SubSelectQueryFormPane.XML_QUERY_TYPE_VALUE));
                 tab.setClosable(false);
                 addTab(tab);
                 return tab;
         }
 
         return null;
     }
 
     /**
      * Vrati vybranou zalozku.
      *
      * @return vybranou zalozka
      */
     public Tab getCurrentTab() {
         return getSelectionModel().getSelectedItem();
     }
 
     /**
      * Vlozi zalozku a vybere ji.
      *
      * @param tab vkladana zalozka
      */
     private void addAndSelectTab(final Tab tab) {
         getTabs().add(tab);
         getSelectionModel().select(tab);
     }
 
 }