/*******************************************************************************
 * Copyright (c) 2010 BSI Business Systems Integration AG.
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 *
 *  Contributors:
 *      BSI Business Systems Integration AG - initial API and implementation
 ******************************************************************************/
package org.eclipse.scout.sdk.rap.ui.internal.wizard.project;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Set;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.scout.commons.CompareUtility;
import org.eclipse.scout.commons.StringUtility;
import org.eclipse.scout.sdk.Texts;
import org.eclipse.scout.sdk.operation.project.IScoutProjectNewOperation;
import org.eclipse.scout.sdk.operation.util.InstallTargetPlatformFileOperation;
import org.eclipse.scout.sdk.rap.IScoutSdkRapConstants;
import org.eclipse.scout.sdk.rap.operations.project.AppendRapTargetOperation;
import org.eclipse.scout.sdk.rap.operations.project.AppendRapTargetOperation.TARGET_STRATEGY;
import org.eclipse.scout.sdk.rap.operations.project.CreateUiRapPluginOperation;
import org.eclipse.scout.sdk.rap.ui.internal.ScoutSdkRapUI;
import org.eclipse.scout.sdk.ui.fields.FileSelectionField;
import org.eclipse.scout.sdk.ui.fields.IFileSelectionListener;
import org.eclipse.scout.sdk.ui.internal.wizard.newproject.ScoutProjectNewWizard;
import org.eclipse.scout.sdk.ui.wizard.project.AbstractProjectNewWizardPage;
import org.eclipse.scout.sdk.util.PropertyMap;
import org.eclipse.scout.sdk.util.resources.ResourceUtility;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.TraverseEvent;
import org.eclipse.swt.events.TraverseListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Group;

public class RapTargetPlatformWizardPage extends AbstractProjectNewWizardPage {

  private static final String[] RAP_PLUGIN_DETECTION_PREFIXES = new String[]{"org.eclipse.rap.rwt_3", "org.eclipse.scout.rt.ui.rap_4.1", "org.eclipse.scout.rt.ui.rap.mobile_4.1"};
  private static final String RAP_TARGET_DEFAULT_SUB_FOLDER = "rap_target";

  private static final String PROP_TARGET_STRATEGY = "propTargetStrategy";
  private static final String PROP_LOCAL_TARGET_FOLDER = "propLocalTargetFolder";
  private static final String PROP_EXTRACT_TARGET_FOLDER = "propExtractTargetFolder";

  private static final int LABEL_PERCENTAGE = 20;

  private Button m_extractButton;
  private Button m_remoteButton;
  private Button m_localButton;
  private Button m_laterButton;

  private Control m_extractTargetGroup;
  private Control m_localTargetGroup;

  private FileSelectionField m_extractTargetLocationField;
  private FileSelectionField m_localTargetLocationField;

  private TARGET_STRATEGY[] m_offeredTargetStrategies;

  public RapTargetPlatformWizardPage() {
    this(TARGET_STRATEGY.values());
  }

  public RapTargetPlatformWizardPage(TARGET_STRATEGY[] offeredTargetStrategies) {
    super(RapTargetPlatformWizardPage.class.getName());
    setTitle(Texts.get("RapTargetDownloadWizardPageTitle"));
    initOfferedTargetStrategies(offeredTargetStrategies);

    File defRap = getDefaultRapLocation();
    if (defRap != null && defRap.exists() && isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING)) {
      setTargetStrategy(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING);
      setLocalTargetFolder(defRap.getAbsolutePath());
      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT)) {
        setExtractTargetFolder(defRap.getAbsolutePath());
      }
    }
    else {
      setLocalTargetFolder(ResourceUtility.getEclipseInstallLocation().getAbsolutePath());
      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT)) {
        setTargetStrategy(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT);
        if (defRap != null) {
          setExtractTargetFolder(defRap.getAbsolutePath());
        }
      }
      else if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_REMOTE)) {
        setTargetStrategy(TARGET_STRATEGY.STRATEGY_REMOTE);
      }
      else if (getOfferedTargetStrategies().length > 0) {
        setTargetStrategy(getOfferedTargetStrategies()[0]);
      }
    }
  }

  @Override
  protected void createContent(Composite parent) {
    if (getOfferedTargetStrategies().length > 1) {
      Composite switchBox = new Composite(parent, SWT.NONE);

      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT)) {
        m_extractButton = new Button(switchBox, SWT.RADIO);
        m_extractButton.setText(Texts.get("CreateNewRAPTarget"));
        m_extractButton.setSelection(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT.equals(getTargetStrategy()));
        m_extractButton.addSelectionListener(new P_StrategySelectionListener(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT));
      }

      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_REMOTE)) {
        m_remoteButton = new Button(switchBox, SWT.RADIO);
        m_remoteButton.setText(Texts.get("DownloadRAPTarget"));
        m_remoteButton.setSelection(TARGET_STRATEGY.STRATEGY_REMOTE.equals(getTargetStrategy()));
        m_remoteButton.addSelectionListener(new P_StrategySelectionListener(TARGET_STRATEGY.STRATEGY_REMOTE));
      }

      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING)) {
        m_localButton = new Button(switchBox, SWT.RADIO);
        m_localButton.setText(Texts.get("LocalRAPTarget"));
        m_localButton.setSelection(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING.equals(getTargetStrategy()));
        m_localButton.addSelectionListener(new P_StrategySelectionListener(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING));
      }

      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LATER)) {
        m_laterButton = new Button(switchBox, SWT.RADIO);
        m_laterButton.setText(Texts.get("InstallRapTargetLater"));
        m_laterButton.setSelection(TARGET_STRATEGY.STRATEGY_LATER.equals(getTargetStrategy()));
        m_laterButton.addSelectionListener(new P_StrategySelectionListener(TARGET_STRATEGY.STRATEGY_LATER));
      }

      switchBox.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
      switchBox.setLayout(new GridLayout(getOfferedTargetStrategies().length, true));
    }

    if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT)) {
      m_extractTargetGroup = createExtractTargetGroup(parent);
      m_extractTargetGroup.setVisible(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT.equals(getTargetStrategy()));

      GridData extractGroupData = new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL);
      extractGroupData.exclude = !TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT.equals(getTargetStrategy());
      m_extractTargetGroup.setLayoutData(extractGroupData);
    }

    if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING)) {
      m_localTargetGroup = createLocalTargetGroup(parent);
      m_localTargetGroup.setVisible(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING.equals(getTargetStrategy()));

      GridData localGroupData = new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL);
      localGroupData.exclude = !TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING.equals(getTargetStrategy());
      m_localTargetGroup.setLayoutData(localGroupData);
    }

    //layout
    parent.setLayout(new GridLayout(1, true));
  }

  private File getDefaultRapLocation() {
    File l = ResourceUtility.getEclipseInstallLocation();
    File ret = null;
    if (l != null) {
      ret = new File(l, RAP_TARGET_DEFAULT_SUB_FOLDER);
    }
    else {
      File[] roots = File.listRoots();
      if (roots.length > 0) {
        ret = new File(roots[0], RAP_TARGET_DEFAULT_SUB_FOLDER);
      }
    }
    return ret;
  }

  private Control createExtractTargetGroup(Composite parent) {
    Group group = new Group(parent, SWT.SHADOW_ETCHED_IN);
    group.setText(Texts.get("CreateNewRAPTarget"));
    m_extractTargetLocationField = new FileSelectionField(group, LABEL_PERCENTAGE);
    m_extractTargetLocationField.setLabelText(Texts.get("RAPTargetLocation"));
    m_extractTargetLocationField.setFolderMode(true);
    m_extractTargetLocationField.setFile(new File(getExtractTargetFolder()));
    m_extractTargetLocationField.addTraverseListener(new TraverseListener() {
      @Override
      public void keyTraversed(TraverseEvent e) {
        if (e.detail == SWT.TRAVERSE_TAB_NEXT || e.detail == SWT.TRAVERSE_ARROW_NEXT) {
          File f = getFileFromInputString(m_extractTargetLocationField.getText());
          File existing = new File(getExtractTargetFolder());
          if (f != null && !f.equals(existing)) {
            setExtractTargetFolderInternal(f.getAbsolutePath());
            pingStateChanging();
          }
        }
      }
    });
    m_extractTargetLocationField.addProductSelectionListener(new IFileSelectionListener() {
      @Override
      public void fileSelected(File file) {
        String fileName = "";
        if (file != null) {
          fileName = file.getAbsolutePath();
        }
        setExtractTargetFolderInternal(fileName);
        pingStateChanging();
      }
    });

    // layout
    group.setLayout(new GridLayout(1, true));
    m_extractTargetLocationField.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL));

    return group;
  }

  private File getFileFromInputString(String input) {
    try {
      if (StringUtility.hasText(input)) {
        if (input.contains(InstallTargetPlatformFileOperation.ECLIPSE_HOME_VAR)) {
          input = input.replace(InstallTargetPlatformFileOperation.ECLIPSE_HOME_VAR, ResourceUtility.getEclipseInstallLocation().getAbsolutePath());
        }
        return new File(input);
      }
    }
    catch (Exception e) {
    }
    return new File("");
  }

  private Control createLocalTargetGroup(Composite parent) {
    Group group = new Group(parent, SWT.SHADOW_ETCHED_IN);
    group.setText(Texts.get("LocalRAPTarget"));
    m_localTargetLocationField = new FileSelectionField(group, LABEL_PERCENTAGE);
    m_localTargetLocationField.setLabelText(Texts.get("RAPTargetLocation"));
    m_localTargetLocationField.setFolderMode(true);
    m_localTargetLocationField.setFile(new File(getLocalTargetFolder()));
    m_localTargetLocationField.addTraverseListener(new TraverseListener() {
      @Override
      public void keyTraversed(TraverseEvent e) {
        if (e.detail == SWT.TRAVERSE_TAB_NEXT || e.detail == SWT.TRAVERSE_ARROW_NEXT) {
          File f = getFileFromInputString(m_localTargetLocationField.getText());
          File existing = new File(getLocalTargetFolder());
          if (f != null && !f.equals(existing)) {
            setLocalTargetFolderInternal(f.getAbsolutePath());
            pingStateChanging();
          }
        }
      }
    });
    m_localTargetLocationField.addProductSelectionListener(new IFileSelectionListener() {
      @Override
      public void fileSelected(File file) {
        String fileName = "";
        if (file != null) {
          fileName = file.getAbsolutePath();
        }
        setLocalTargetFolderInternal(fileName);
        pingStateChanging();
      }
    });

    // layout
    group.setLayout(new GridLayout(1, true));
    m_localTargetLocationField.setLayoutData(new GridData(GridData.GRAB_HORIZONTAL | GridData.FILL_HORIZONTAL));

    return group;
  }

  @Override
  public ScoutProjectNewWizard getWizard() {
    return (ScoutProjectNewWizard) super.getWizard();
  }

  @Override
  @SuppressWarnings("unchecked")
  public void putProperties(PropertyMap properties) {
    Set<String> checkedNodeIds = properties.getProperty(IScoutProjectNewOperation.PROP_PROJECT_CHECKED_NODES, Set.class);
    if (checkedNodeIds != null && checkedNodeIds.contains(CreateUiRapPluginOperation.BUNDLE_ID)) {
      properties.setProperty(AppendRapTargetOperation.PROP_LOCAL_TARGET_FOLDER, getLocalTargetFolder());
      properties.setProperty(AppendRapTargetOperation.PROP_EXTRACT_TARGET_FOLDER, getExtractTargetFolder());
      properties.setProperty(AppendRapTargetOperation.PROP_TARGET_STRATEGY, getTargetStrategy());
    }
  }

  @Override
  public void performHelp() {
    //TODO: remove external link and use eclipse help instead
    ResourceUtility.showUrlInBrowser("https://wiki.eclipse.org/Scout/HowTo/4.0/Create_a_new_project#Step_3_.28Optional.29");
  }

  public void setTargetStrategy(TARGET_STRATEGY strategy) {
    try {
      if (strategy == null) {
        strategy = TARGET_STRATEGY.STRATEGY_REMOTE;
      }
      setTargetStrategyInternal(strategy);
      if (isControlCreated()) {
        switch (strategy) {
          case STRATEGY_LOCAL_EXISTING:
            if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING)) {
              m_localButton.setSelection(true);
            }
            break;
          case STRATEGY_LOCAL_EXTRACT:
            if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT)) {
              m_extractButton.setSelection(true);
            }
            break;
          case STRATEGY_REMOTE:
            if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_REMOTE)) {
              m_remoteButton.setSelection(true);
            }
            break;
          case STRATEGY_LATER:
            if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LATER)) {
              m_laterButton.setSelection(true);
            }
            break;
        }
      }
    }
    finally {
      setStateChanging(false);
    }
  }

  private void setTargetStrategyInternal(TARGET_STRATEGY strategy) {
    if (!isStrategyOffered(strategy)) {
      throw new IllegalArgumentException("unsupported strategy: " + strategy);
    }
    setProperty(PROP_TARGET_STRATEGY, strategy);
  }

  public TARGET_STRATEGY getTargetStrategy() {
    return (TARGET_STRATEGY) getProperty(PROP_TARGET_STRATEGY);
  }

  public String getExtractTargetFolder() {
    return (String) getProperty(PROP_EXTRACT_TARGET_FOLDER);
  }

  public void setExtractTargetFolder(String proposal) {
    try {
      setStateChanging(true);
      setExtractTargetFolderInternal(proposal);
      if (isControlCreated() && m_extractTargetLocationField != null) {
        m_extractTargetLocationField.setFileName(proposal);
      }
    }
    finally {
      setStateChanging(false);
    }
  }

  private void setExtractTargetFolderInternal(String extractTargetLocation) {
    if (extractTargetLocation != null) {
      extractTargetLocation = extractTargetLocation.trim();
    }
    setProperty(PROP_EXTRACT_TARGET_FOLDER, extractTargetLocation);
  }

  public String getLocalTargetFolder() {
    return (String) getProperty(PROP_LOCAL_TARGET_FOLDER);
  }

  public void setLocalTargetFolder(String proposal) {
    try {
      setStateChanging(true);
      setLocalTargetFolderInternal(proposal);
      if (isControlCreated() && m_localTargetLocationField != null) {
        m_localTargetLocationField.setFileName(proposal);
      }
    }
    finally {
      setStateChanging(false);
    }
  }

  private void setLocalTargetFolderInternal(String localTargetLocation) {
    if (localTargetLocation != null) {
      localTargetLocation = localTargetLocation.trim();
    }
    setProperty(PROP_LOCAL_TARGET_FOLDER, localTargetLocation);
  }

  @Override
  protected void validatePage(MultiStatus multiStatus) {
    multiStatus.add(getStatusStrategy());
  }

  private boolean isStrategyOffered(TARGET_STRATEGY strategy) {
    for (TARGET_STRATEGY item : getOfferedTargetStrategies()) {
      if (item.equals(strategy)) {
        return true;
      }
    }
    return false;
  }

  private IStatus getStatusStrategy() {
    if (TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING.equals(getTargetStrategy())) {
      if (!StringUtility.hasText(getLocalTargetFolder())) {
        return new Status(IStatus.ERROR, ScoutSdkRapUI.PLUGIN_ID, Texts.get("NoRAPTargetLocationDefined"));
      }
      File target = new File(getLocalTargetFolder());
      if (!target.exists() || !new File(target, "plugins").exists()) {
        return new Status(IStatus.ERROR, ScoutSdkRapUI.PLUGIN_ID, Texts.get("NoRAPTargetFoundUnder", getLocalTargetFolder()));
      }
      else {
        try {
          // try to find rap-rt, scout-rap-rt and scout-mobile-rt plugins
          File pluginsFolder = new File(new File(getLocalTargetFolder()), "plugins");
          if (pluginsFolder.exists()) {
            String[] pluginNames = pluginsFolder.list(new FilenameFilter() {
              @Override
              public boolean accept(File dir, String name) {
                String n = name.toLowerCase().trim();
                for (String s : RAP_PLUGIN_DETECTION_PREFIXES) {
                  if (n.startsWith(s) && n.endsWith(".jar")) {
                    return true;
                  }
                }
                return false;
              }
            });
            if (pluginNames.length == RAP_PLUGIN_DETECTION_PREFIXES.length) {
              return Status.OK_STATUS;
            }
          }
        }
        catch (IllegalArgumentException e) {
          ScoutSdkRapUI.logError("could not parse rap feature version.", e);
        }
        return new Status(IStatus.ERROR, ScoutSdkRapUI.PLUGIN_ID, Texts.get("NoRAPTargetFoundUnder", getLocalTargetFolder()));
      }
    }
    else if (TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT.equals(getTargetStrategy())) {
      if (!StringUtility.hasText(getExtractTargetFolder())) {
        return new Status(IStatus.ERROR, ScoutSdkRapUI.PLUGIN_ID, Texts.get("NoRAPTargetLocationDefined"));
      }
      File eclipseFolder = ResourceUtility.getEclipseInstallLocation();
      File targetDir = new File(getExtractTargetFolder());
      if (CompareUtility.equals(eclipseFolder, targetDir)) {
        return new Status(IStatus.ERROR, ScoutSdkRapUI.PLUGIN_ID, Texts.get("RAPTargetNotInstallableInPlatform"));
      }
      if (targetDir.exists()) {
        return new Status(IStatus.WARNING, ScoutSdkRapUI.PLUGIN_ID, Texts.get("RAPTargetAlreadyExists"));
      }
      else {
        return new Status(IStatus.INFO, ScoutSdkRapUI.PLUGIN_ID, Texts.get("ANewRAPTargetWillBeCreated", getExtractTargetFolder()));
      }
    }
    else if (TARGET_STRATEGY.STRATEGY_REMOTE.equals(getTargetStrategy())) {
      return new Status(IStatus.INFO, ScoutSdkRapUI.PLUGIN_ID, Texts.get("TheRAPTargetWillBeDownloaded"));
    }
    else if (TARGET_STRATEGY.STRATEGY_LATER.equals(getTargetStrategy())) {
      return new Status(IStatus.INFO, ScoutSdkRapUI.PLUGIN_ID, Texts.get("NoRAPTargetWillBeSet"));
    }
    return Status.OK_STATUS;
  }

  public TARGET_STRATEGY[] getOfferedTargetStrategies() {
    return m_offeredTargetStrategies;
  }

  private void initOfferedTargetStrategies(TARGET_STRATEGY[] offeredTargetStrategies) {
    boolean isRapTargetPluginAvailable = Platform.getBundle(IScoutSdkRapConstants.ScoutRapTargetPlugin) != null;

    if (!isRapTargetPluginAvailable) {
      // the rap target plugin is not installed: filter the strategy out if it is in the list
      ArrayList<TARGET_STRATEGY> strategies = new ArrayList<TARGET_STRATEGY>(offeredTargetStrategies.length);
      for (TARGET_STRATEGY s : offeredTargetStrategies) {
        if (!TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT.equals(s)) {
          strategies.add(s);
        }
      }
      offeredTargetStrategies = strategies.toArray(new TARGET_STRATEGY[strategies.size()]);
    }

    m_offeredTargetStrategies = offeredTargetStrategies;
  }

  private class P_StrategySelectionListener extends SelectionAdapter {
    private final TARGET_STRATEGY m_strategy;

    public P_StrategySelectionListener(TARGET_STRATEGY strategy) {
      m_strategy = strategy;
    }

    private void setGroupVisible(Control toBeVisible) {
      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXISTING)) {
        boolean localVisible = m_localTargetGroup == toBeVisible;
        m_localTargetGroup.setVisible(localVisible);
        ((GridData) m_localTargetGroup.getLayoutData()).exclude = !localVisible;
      }

      if (isStrategyOffered(TARGET_STRATEGY.STRATEGY_LOCAL_EXTRACT)) {
        boolean extractVisible = m_extractTargetGroup == toBeVisible;
        m_extractTargetGroup.setVisible(extractVisible);
        ((GridData) m_extractTargetGroup.getLayoutData()).exclude = !extractVisible;
      }
    }

    @Override
    public void widgetSelected(SelectionEvent e) {
      setTargetStrategyInternal(m_strategy);
      switch (m_strategy) {
        case STRATEGY_LOCAL_EXISTING:
          setGroupVisible(m_localTargetGroup);
          break;
        case STRATEGY_LOCAL_EXTRACT:
          setGroupVisible(m_extractTargetGroup);
          break;
        case STRATEGY_REMOTE:
          setGroupVisible(null);
          break;
        case STRATEGY_LATER:
          setGroupVisible(null);
          break;
      }
      m_localTargetGroup.getParent().layout(true);
      pingStateChanging();
    }
  } // end class P_StrategySelectionListener
}