/*
 * Copyright (c) 2019 Ed Merks and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *    Ed Merks - initial API and implementation
 */
package org.eclipse.oomph.setup.internal.installer;

import org.eclipse.oomph.internal.setup.SetupProperties;
import org.eclipse.oomph.util.IOUtil;
import org.eclipse.oomph.util.OS;
import org.eclipse.oomph.util.OomphPlugin.Preference;
import org.eclipse.oomph.util.PropertiesUtil;
import org.eclipse.oomph.util.ReflectUtil;
import org.eclipse.oomph.util.StringUtil;

import org.eclipse.emf.common.util.URI;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.urischeme.IOperatingSystemRegistration;
import org.eclipse.urischeme.IScheme;
import org.eclipse.urischeme.ISchemeInformation;

import java.io.File;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

public final class URISchemeUtil
{
  private static final Preference PREF_WEB_LINKS = SetupInstallerPlugin.INSTANCE.getConfigurationPreference("web-links"); //$NON-NLS-1$

  private static final IOperatingSystemRegistration OPERATING_SYSTEM_REGISTRATION = ReflectUtil.invokeMethod("getInstance", IOperatingSystemRegistration.class); //$NON-NLS-1$

  private static final String INSTALLER_SCHEME = PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALLER_URI_SCHEME + "installer", "eclipse+installer"); //$NON-NLS-1$ //$NON-NLS-2$

  private static final String MARKETPLACE_SCHEME = PropertiesUtil.getProperty(SetupProperties.PROP_SETUP_INSTALLER_URI_SCHEME + "mpc", "?"); //$NON-NLS-1$ //$NON-NLS-2$

  private static final String FAKE_ECLIPSE_HOME = PropertiesUtil.getProperty("oomph.setup.installer.uri.scheme.eclipse.home", null); //$NON-NLS-1$

  private static final Collection<IScheme> SCHEMES;

  static
  {
    Collection<IScheme> schemes = new ArrayList<>();
    for (final String scheme : new String[] { INSTALLER_SCHEME, MARKETPLACE_SCHEME })
    {
      if (URI.validScheme(scheme))
      {
        schemes.add(new IScheme()
        {
          @Override
          public String getName()
          {
            return scheme;
          }

          @Override
          public String getDescription()
          {
            return scheme;
          }
        });
      }
    }

    SCHEMES = schemes;
  }

  private URISchemeUtil()
  {
  }

  /**
   * Converts the argument to a URI, resolving the URI if it's one of the registered web link schemes.
   * It first tries to interpret the argument as a file system file, checking if that is really a file that can be read;
   * in that case it will yield a file: URI.
   * Otherwise it's interpreted as a URI, except on Windows if the result has a scheme with a single letter, in which case
   * it will also yield a file: URI.
   * If the URI uses a web link scheme, the URI is resolved to yield a normalized URI that can be used directly as normal.
   */
  public static URI getResourceURI(String argument)
  {
    try
    {
      File file = new File(argument);
      if (file.isFile() && file.canRead())
      {
        return URI.createFileURI(IOUtil.getCanonicalFile(file).toString());
      }
    }
    catch (Throwable ex)
    {
      //$FALL-THROUGH$
    }

    URI uri = URI.createURI(argument);
    String scheme = uri.scheme();
    if (scheme == null || OS.INSTANCE.isWin() && scheme.length() == 1)
    {
      uri = URI.createFileURI(IOUtil.getCanonicalFile(new File(argument)).toString());
    }

    if (INSTALLER_SCHEME.equals(uri.scheme()) && uri.opaquePart() != null)
    {
      uri = URI.createURI(uri.opaquePart()).appendQuery(uri.query()).appendFragment(uri.fragment());
    }

    return uri;
  }

  /**
   * Returns this installer's launcher, or the empty string.
   * The latter is always yielded for a debug launch.
   */
  public static String getSelfLauncher()
  {
    Runnable restore = setEclipseHome(FAKE_ECLIPSE_HOME);
    String eclipseLauncher = OPERATING_SYSTEM_REGISTRATION.getEclipseLauncher();
    if (restore != null)
    {
      restore.run();
    }
    return StringUtil.isEmpty(eclipseLauncher) || eclipseLauncher.startsWith("file:") ? "" : eclipseLauncher; //$NON-NLS-1$ //$NON-NLS-2$
  }

  private static Runnable setEclipseHome(String eclipseHome)
  {
    if (!StringUtil.isEmpty(eclipseHome))
    {
      final String originalHomeLocation = System.getProperty("eclipse.home.location"); //$NON-NLS-1$
      System.setProperty("eclipse.home.location", eclipseHome); //$NON-NLS-1$
      return new Runnable()
      {
        @Override
        public void run()
        {
          System.setProperty("eclipse.home.location", originalHomeLocation); //$NON-NLS-1$
        }
      };
    }

    return null;
  }

  /**
   * Registers this installer for any scheme that does not have a conflicting registration.
   */
  public static void registerDefault()
  {
    boolean isSet = PREF_WEB_LINKS.get((String)null) != null;
    if (!isSet && canRegister())
    {
      Map<String, String> conflictingRegistrations = getConflictingRegistrations();
      for (IScheme scheme : SCHEMES)
      {
        String schemeName = scheme.getName();
        if (!conflictingRegistrations.containsKey(schemeName))
        {
          setRegistrations(Collections.singletonMap(schemeName, getSelfLauncher()));
        }
      }
    }
  }

  /**
   * Returns true only if the registry is accessible, if the self launcher is known, and the installer is one at a permanent disk location.
   */
  private static boolean canRegister()
  {
    try
    {
      OPERATING_SYSTEM_REGISTRATION.getSchemesInformation(SCHEMES);
    }
    catch (Exception ex)
    {
      return false;
    }

    return !StringUtil.isEmpty(getSelfLauncher()) && !KeepInstallerUtil.canKeepInstaller();
  }

  /**
   * Returns true if there is at least one scheme is actually registered for this installer.
   */
  public static boolean isRegistered()
  {
    String eclipseLauncher = getSelfLauncher();
    if (StringUtil.isEmpty(eclipseLauncher))
    {
      return false;
    }

    try
    {
      List<ISchemeInformation> schemesInformation = OPERATING_SYSTEM_REGISTRATION.getSchemesInformation(SCHEMES);
      for (ISchemeInformation schemeInformation : schemesInformation)
      {
        String handlerInstanceLocation = schemeInformation.getHandlerInstanceLocation();
        if (eclipseLauncher.equals(handlerInstanceLocation))
        {
          return true;
        }
      }
    }
    catch (Exception ex)
    {
    }

    return false;
  }

  /**
   * Updates the specified registrations in the system registry.
   */
  public static void setRegistrations(Map<String, String> newRegistrations)
  {
    Map<String, String> existingRegistrations = getRegistrations();
    for (Map.Entry<String, String> entry : newRegistrations.entrySet())
    {
      String schemeRegistration = entry.getKey();
      String existingLauncher = existingRegistrations.get(schemeRegistration);
      String newLauncher = entry.getValue();
      if (!newLauncher.equals(existingLauncher))
      {
        for (IScheme scheme : SCHEMES)
        {
          if (scheme.getName().equals(schemeRegistration))
          {
            try
            {
              if (OS.INSTANCE.isMac())
              {
                // The Mac implementation refuses unregister a conflicting registration so force it.
                Runnable restore = setEclipseHome(existingLauncher);
                try
                {
                  OPERATING_SYSTEM_REGISTRATION.handleSchemes(Collections.<IScheme> emptyList(), Collections.singleton(scheme));
                }
                catch (Exception ex)
                {
                  SetupInstallerPlugin.INSTANCE.log(ex);
                }
                finally
                {
                  if (restore != null)
                  {
                    restore.run();
                  }
                }
              }
              else
              {
                OPERATING_SYSTEM_REGISTRATION.handleSchemes(Collections.<IScheme> emptyList(), Collections.singleton(scheme));
              }

              if (!StringUtil.isEmpty(newLauncher))
              {
                Runnable restore = setEclipseHome(FAKE_ECLIPSE_HOME);
                OPERATING_SYSTEM_REGISTRATION.handleSchemes(Collections.singleton(scheme), Collections.<IScheme> emptyList());
                if (restore != null)
                {
                  restore.run();
                }
              }
            }
            catch (Exception ex)
            {
              SetupInstallerPlugin.INSTANCE.log(ex);
            }

            break;
          }
        }
      }
    }
  }

  /**
   * Registers or unregisters this installer's registrations and remembers this state in the web link preference.
   */
  public static void setRegistered(boolean registered)
  {
    String eclipseLauncher = getSelfLauncher();
    if (!StringUtil.isEmpty(eclipseLauncher))
    {
      try
      {
        if (!registered)
        {
          Set<String> selfRegistrations = getSelfRegistrations();
          for (IScheme scheme : SCHEMES)
          {
            if (selfRegistrations.contains(scheme.getName()))
            {
              OPERATING_SYSTEM_REGISTRATION.handleSchemes(Collections.<IScheme> emptyList(), Collections.singleton(scheme));
            }
          }
        }

        if (registered)
        {
          OPERATING_SYSTEM_REGISTRATION.handleSchemes(SCHEMES, Collections.<IScheme> emptyList());
        }

        PREF_WEB_LINKS.set(registered);
      }
      catch (Exception ex)
      {
        SetupInstallerPlugin.INSTANCE.log(ex);
      }
    }
  }

  /**
   * The result of a registration confirmation.
   */
  enum RegistrationConfirmation
  {
    /**
     * The installer should be kept before registration is possible.
     */
    KEEP_INSTALLER,
    /**
     * It's okay to do the registration.
     */
    OK,
    /**
     * The registration is canceled.
     */
    CANCEL,
    /**
     * The registration has already been completed.
     */
    DONE
  }

  /**
   * Prompts for saving the installer to a permanent location if it is transient returning that result.
   * Otherwise prompts for the choices of which schemes to register, returning that result.
   */
  public static RegistrationConfirmation manageRegistrations(Shell shell)
  {
    if (KeepInstallerUtil.isTransientInstaller())
    {
      if (MessageDialog.openConfirm(shell, Messages.URISchemeUtil_title, Messages.URISchemeUtil_description))
      {
        return RegistrationConfirmation.KEEP_INSTALLER;
      }

      return RegistrationConfirmation.CANCEL;
    }

    URISchemeDialog uriSchemeDialog = new URISchemeDialog(shell);
    if (uriSchemeDialog.open() == Window.CANCEL)
    {
      return RegistrationConfirmation.CANCEL;
    }

    return RegistrationConfirmation.DONE;
  }

  /**
   * Used when enabling registration via the toggle button in simple mode.
   * Prompts for saving the installer to a permanent location if it is transient returning that result.
   * Otherwise, if there are conflicting registrations,
   * prompts for the choices of which schemes to register, returning that result.
   * Otherwise returns OK, i.e., that it's okay to call setRegistered(true) in order to register this installer.
   */
  public static RegistrationConfirmation confirmRegistration(Shell shell)
  {
    if (KeepInstallerUtil.isTransientInstaller())
    {
      if (MessageDialog.openConfirm(shell, Messages.URISchemeUtil_title, Messages.URISchemeUtil_description))
      {
        return RegistrationConfirmation.KEEP_INSTALLER;
      }

      return RegistrationConfirmation.CANCEL;
    }

    Map<String, String> conflictingRegistrations = URISchemeUtil.getConflictingRegistrations();
    if (!conflictingRegistrations.isEmpty())
    {
      URISchemeDialog uriSchemeDialog = new URISchemeDialog(shell);
      if (uriSchemeDialog.open() == Window.CANCEL)
      {
        return RegistrationConfirmation.CANCEL;
      }

      return RegistrationConfirmation.DONE;
    }

    return RegistrationConfirmation.OK;
  }

  /**
   * Returns a map from web link schemes to the current conflicting launcher for that scheme.
   */
  public static Map<String, String> getConflictingRegistrations()
  {
    Map<String, String> result = new LinkedHashMap<>();
    try
    {
      List<ISchemeInformation> schemesInformation = OPERATING_SYSTEM_REGISTRATION.getSchemesInformation(SCHEMES);
      String eclipseLauncher = getSelfLauncher();
      for (ISchemeInformation schemeInformation : schemesInformation)
      {
        String handlerInstanceLocation = schemeInformation.getHandlerInstanceLocation();
        if (!StringUtil.isEmpty(handlerInstanceLocation) && !handlerInstanceLocation.equals(eclipseLauncher))
        {
          result.put(schemeInformation.getName(), handlerInstanceLocation);
        }
      }
    }
    catch (Exception ex)
    {
    }

    return result;
  }

  /**
   * Returns the web link schemes currently registered for this installer.
   */
  public static Set<String> getSelfRegistrations()
  {
    Set<String> result = new LinkedHashSet<>();
    String eclipseLauncher = getSelfLauncher();
    if (!StringUtil.isEmpty(eclipseLauncher))
    {
      try
      {
        List<ISchemeInformation> schemesInformation = OPERATING_SYSTEM_REGISTRATION.getSchemesInformation(SCHEMES);
        for (ISchemeInformation schemeInformation : schemesInformation)
        {
          String handlerInstanceLocation = schemeInformation.getHandlerInstanceLocation();
          if (eclipseLauncher.equals(handlerInstanceLocation))
          {
            result.add(schemeInformation.getName());
          }
        }
      }
      catch (Exception ex)
      {
      }
    }

    return result;
  }

  /**
   * Returns a map from web link scheme to the currently registered launcher for that scheme.
   */
  public static Map<String, String> getRegistrations()
  {
    Map<String, String> result = new LinkedHashMap<>();
    try
    {
      List<ISchemeInformation> schemesInformation = OPERATING_SYSTEM_REGISTRATION.getSchemesInformation(SCHEMES);
      for (ISchemeInformation schemeInformation : schemesInformation)
      {
        String handlerInstanceLocation = schemeInformation.getHandlerInstanceLocation();
        result.put(schemeInformation.getName(), handlerInstanceLocation);
      }
    }
    catch (Exception ex)
    {
    }

    return result;
  }
}