# Copyright 2021 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import abc
import logging
import os
import plistlib
import subprocess
import time
import typing

import utils


class BrowserDriver(abc.ABC):
  """Abstract Base Class encapsulating browser setup and tear down.
  """

  def __init__(self, browser_name: str, process_name: str):
    self.name = browser_name
    self.process_name = process_name
    self.browser_process = None

    # LaunchServices can get confused when an application is launched from
    # more than one location and break AppleScript commands. Always launch
    # browsers from /Applications to avoid such problems.
    self.executable_path = (os.path.join("/Applications",
                                         f"{self.process_name}.app"))

    if not os.path.exists(self.executable_path):
      raise ValueError(f"Application doesn't exist for {browser_name}.")

  @abc.abstractmethod
  def Launch(self):
    """Starts the browser and ensures it is started before returning.
    """
    pass

  def TearDown(self):
    """Terminates the browser and ensures it's cleaned up before returning.
    """
    logging.debug(f"Tearing down {self.process_name}")
    if self.browser_process:
      utils.TerminateProcess(self.browser_process)

  def GetApplicationInfo(self) -> typing.Dict:
    """ Returns the Info.plist data in the application folder. """
    plist_path = os.path.join(self.executable_path, "Contents", "Info.plist")
    with open(plist_path, 'rb') as plist_file:
      return plistlib.load(plist_file)

  def Summary(self):
    """Returns a dictionary describing the browser.
    """
    info = self.GetApplicationInfo()
    return {
        'name': self.name,
        'version': info['CFBundleShortVersionString'],
        'identifier': info['CFBundleIdentifier']
    }

  def _EnsureStarted(self):
    """Waits until a browser with the given `process_name` is running.
    """
    while not self.browser_process:
      self.browser_process = utils.FindProcess(self.process_name)
      time.sleep(0.100)
      logging.debug(f"Waiting for {self.process_name} to start")
    logging.debug(f"{self.process_name} started")


class SafariDriver(BrowserDriver):
  def __init__(self, extra_args=[]):
    super().__init__("safari", "Safari")
    self.extra_args = extra_args

  def Launch(self):
    subprocess.call(["open", "-a", "Safari"])
    # Call prep_safari.scpt to make sure the run starts clean. See file
    # comment for details.
    subprocess.call([
        "osascript",
        os.path.join(os.path.dirname(__file__), "driver_scripts_templates",
                     "prep_safari.scpt")
    ])
    subprocess.call(["open", "-a", "Safari", "--args"] + self.extra_args)

    self._EnsureStarted()


class ChromiumDriver(BrowserDriver):
  def __init__(self,
               browser_name: str,
               variation: str,
               process_name: str,
               extra_args=[]):
    if variation != "":
      browser_name += f"_{variation}"
    super().__init__(browser_name, process_name)
    self.extra_args = extra_args


  def Launch(self):
    open_args = ["-a", self.process_name]
    subprocess.call(["open"] + open_args + ["--args"] + [
        "--enable-benchmarking", "--disable-stack-profiler", "--no-first-run",
        "--no-default-browser-check"
    ] + self.extra_args)

    self._EnsureStarted()

  def Summary(self):
    """Returns a dictionary describing the browser.
    """
    info = self.GetApplicationInfo()
    return {
        'name': self.name,
        'identifier': info['CFBundleIdentifier'],
        'version': info['CFBundleShortVersionString'],
        'commit': info['SCMRevision'],
        'extra_args': self.extra_args
    }


# Helper functions to get default browser configurations.


def Safari():
  return SafariDriver()


def Chrome(variation, extra_args=[]):
  return ChromiumDriver("chrome",
                        variation,
                        "Google Chrome",
                        extra_args=extra_args)


def Canary(variation, extra_args=[]):
  return ChromiumDriver("canary",
                        variation,
                        "Google Chrome Canary",
                        extra_args=extra_args)


def Chromium(variation, extra_args=[]):
  return ChromiumDriver("chromium",
                        variation,
                        "Chromium",
                        extra_args=extra_args)


def Edge(variation, extra_args=[]):
  return ChromiumDriver("edge",
                        variation,
                        "Microsoft Edge",
                        extra_args=extra_args)


PROCESS_NAMES = [
    "Safari", "Google Chrome", "Google Chrome Canary", "Chromium",
    "Microsoft Edge"
]


def MakeBrowserDriver(browser_name: str,
                      variation: str,
                      chrome_user_dir=None,
                      output_dir=None,
                      tracing_mode=False,
                      extra_command_line=None) -> BrowserDriver:
  """Creates browser driver by name.

  Args:
    browser_name: Identifier for the browser to create. Supported browsers
      are: safari, chrome and chromium.
    chrome_user_dir: Optional user directory path to use for chrome.
  """

  if "safari" == browser_name:
    return Safari()
  if browser_name in ["chrome", "chromium", "canary", "edge"]:
    if chrome_user_dir:
      chrome_extra_arg = [f"--user-data-dir={chrome_user_dir}"]
    else:
      chrome_extra_arg = ["--guest"]
    if variation == 'AlignWakeUps':
      chrome_extra_arg += ['--enable-features=AlignWakeUps']

    if tracing_mode:
      chrome_extra_arg += [
          '--enable-tracing=toplevel,toplevel.flow,mojom,navigation'
      ]
      trace_path = os.path.join(output_dir, "chrometrace.log")
      chrome_extra_arg += [
          f'--trace-startup-file={os.path.abspath(trace_path)}'
      ]

    if extra_command_line:
      for command in extra_command_line:
        # Quotes are needed to avoid to avoid cli replacement.
        command = command.replace('"', '')
        chrome_extra_arg += [command]

    if browser_name == "chrome":
      return Chrome(variation, extra_args=chrome_extra_arg)
    if browser_name == "canary":
      return Canary(variation, extra_args=chrome_extra_arg)
    elif browser_name == "chromium":
      return Chromium(variation, extra_args=chrome_extra_arg)
    elif browser_name == "edge":
      return Edge(variation, extra_args=chrome_extra_arg)
  return None