import json
from jsonpath_rw import parse

class SafeDictSetter(object):
  """ Specialized write-only dictionary wrapper class that allows for setting
      nested keys via a path syntax.

      Example:
        sds = SafeDictSetter()
        sds['foo.bar.baz'] = 'hello' # Sets 'foo' = {'bar': {'baz': 'hello'}}
        sds['somekey'] = None # Does not set the key since the value is None
  """
  def __init__(self, initial_object=None):
    self._object = initial_object or {}

  def __setitem__(self, path, value):
    self.set(path, value)

  def set(self, path, value, allow_none=False):
    """ Sets the value of the given path to the given value. """
    if value is None and not allow_none:
      return

    pieces = path.split('.')
    current = self._object

    for piece in pieces[:len(pieces)-1]:
      current_obj = current.get(piece, {})
      if not isinstance(current_obj, dict):
        raise Exception('Key %s is a non-object value: %s' % (piece, current_obj))

      current[piece] = current_obj
      current = current_obj

    current[pieces[-1]] = value

  def dict_value(self):
    """ Returns the dict value built. """
    return self._object

  def json_value(self):
    """ Returns the JSON string value of the dictionary built. """
    return json.dumps(self._object)


class JSONPathDict(object):
  """ Specialized read-only dictionary wrapper class that uses the jsonpath_rw library
      to access keys via an X-Path-like syntax.

      Example:
        pd = JSONPathDict({'hello': {'hi': 'there'}})
        pd['hello.hi'] # Returns 'there'
  """
  def __init__(self, dict_value):
    """ Init the helper with the JSON object.
    """
    self._object = dict_value

  def __getitem__(self, path):
    return self.get(path)

  def __iter__(self):
    return self._object.itervalues()

  def iterkeys(self):
    return self._object.iterkeys()

  def get(self, path, not_found_handler=None):
    """ Returns the value found at the given path. Path is a json-path expression. """
    if self._object == {} or self._object is None:
      return None
    jsonpath_expr = parse(path)

    try:
      matches = jsonpath_expr.find(self._object)
    except IndexError:
      return None

    if not matches:
      return not_found_handler() if not_found_handler else None

    match = matches[0].value
    if not match:
      return not_found_handler() if not_found_handler else None

    if isinstance(match, dict):
      return JSONPathDict(match)

    return match

  def keys(self):
    return self._object.keys()