import os
import logging

from util.config.provider.baseprovider import (BaseProvider, import_yaml, export_yaml,
                                               CannotWriteConfigException)

logger = logging.getLogger(__name__)

def _ensure_parent_dir(filepath):
  """ Ensures that the parent directory of the given file path exists. """
  try:
    parentpath = os.path.abspath(os.path.join(filepath, os.pardir))
    if not os.path.isdir(parentpath):
      os.makedirs(parentpath)
  except IOError as ioe:
    raise CannotWriteConfigException(str(ioe))


class FileConfigProvider(BaseProvider):
  """ Implementation of the config provider that reads the data from the file system. """
  def __init__(self, config_volume, yaml_filename, py_filename):
    self.config_volume = config_volume
    self.yaml_filename = yaml_filename
    self.py_filename = py_filename

    self.yaml_path = os.path.join(config_volume, yaml_filename)
    self.py_path = os.path.join(config_volume, py_filename)

  @property
  def provider_id(self):
    return 'file'

  def update_app_config(self, app_config):
    if os.path.exists(self.py_path):
      logger.debug('Applying config file: %s', self.py_path)
      app_config.from_pyfile(self.py_path)

    if os.path.exists(self.yaml_path):
      logger.debug('Applying config file: %s', self.yaml_path)
      import_yaml(app_config, self.yaml_path)

  def get_config(self):
    if not os.path.exists(self.yaml_path):
      return None

    config_obj = {}
    import_yaml(config_obj, self.yaml_path)
    return config_obj

  def save_config(self, config_obj):
    export_yaml(config_obj, self.yaml_path)

  def config_exists(self):
    return self.volume_file_exists(self.yaml_filename)

  def volume_exists(self):
    return os.path.exists(self.config_volume)

  def volume_file_exists(self, filename):
    return os.path.exists(os.path.join(self.config_volume, filename))

  def get_volume_file(self, filename, mode='r'):
    return open(os.path.join(self.config_volume, filename), mode=mode)

  def write_volume_file(self, filename, contents):
    filepath = os.path.join(self.config_volume, filename)
    _ensure_parent_dir(filepath)

    try:
      with open(filepath, mode='w') as f:
        f.write(contents)
    except IOError as ioe:
      raise CannotWriteConfigException(str(ioe))

    return filepath

  def remove_volume_file(self, filename):
    filepath = os.path.join(self.config_volume, filename)
    os.remove(filepath)

  def list_volume_directory(self, path):
    dirpath = os.path.join(self.config_volume, path)
    if not os.path.exists(dirpath):
      return None

    if not os.path.isdir(dirpath):
      return None

    return os.listdir(dirpath)

  def save_volume_file(self, filename, flask_file):
    filepath = os.path.join(self.config_volume, filename)
    _ensure_parent_dir(filepath)

    # Write the file.
    try:
      flask_file.save(filepath)
    except IOError as ioe:
      raise CannotWriteConfigException(str(ioe))

    return filepath

  def requires_restart(self, app_config):
    file_config = self.get_config()
    if not file_config:
      return False

    for key in file_config:
      if app_config.get(key) != file_config[key]:
        return True

    return False
  
  def get_volume_path(self, directory, filename):
    return os.path.join(directory, filename)