// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_
#define CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_

#include <iterator>
#include <map>

#include "base/memory/linked_ptr.h"
#include "chrome/common/extensions/permissions/api_permission.h"

namespace base {
class ListValue;
}  // namespace base

namespace extensions {

class Extension;

typedef std::map<APIPermission::ID,
  linked_ptr<APIPermission> > APIPermissionMap;

class APIPermissionSet {
 public:
  class const_iterator :
    public std::iterator<std::input_iterator_tag, const APIPermission*> {
   public:
    const_iterator(const APIPermissionMap::const_iterator& it);
    const_iterator(const const_iterator& ids_it);

    const_iterator& operator++() {
      ++it_;
      return *this;
    }

    const_iterator operator++(int) {
      const_iterator tmp(it_++);
      return tmp;
    }

    bool operator==(const const_iterator& rhs) const {
      return it_ == rhs.it_;
    }

    bool operator!=(const const_iterator& rhs) const {
      return it_ != rhs.it_;
    }

    const APIPermission* operator*() const {
      return it_->second.get();
    }

    const APIPermission* operator->() const {
      return it_->second.get();
    }

   private:
    APIPermissionMap::const_iterator it_;
  };

  enum ParseSource {
    // Don't allow internal permissions to be parsed (e.g. entries in the
    // "permissions" list in a manifest).
    kDisallowInternalPermissions,

    // Allow internal permissions to be parsed (e.g. from the "api" field of a
    // permissions list in the prefs).
    kAllowInternalPermissions,
  };

  APIPermissionSet();

  APIPermissionSet(const APIPermissionSet& set);

  ~APIPermissionSet();

  const_iterator begin() const {
    return const_iterator(map().begin());
  }

  const_iterator end() const {
    return map().end();
  }

  const_iterator find(APIPermission::ID id) const {
    return map().find(id);
  }

  const APIPermissionMap& map() const {
    return map_;
  }

  APIPermissionMap& map() {
    return map_;
  }

  void clear() {
    map_.clear();
  }

  size_t count(APIPermission::ID id) const {
    return map().count(id);
  }

  bool empty() const {
    return map().empty();
  }

  size_t erase(APIPermission::ID id) {
    return map().erase(id);
  }

  size_t size() const {
    return map().size();
  }

  APIPermissionSet& operator=(const APIPermissionSet& rhs);

  bool operator==(const APIPermissionSet& rhs) const;

  bool operator!=(const APIPermissionSet& rhs) const {
    return !operator==(rhs);
  }

  void insert(APIPermission::ID id);

  // Insert |permission| into the APIPermissionSet. The APIPermissionSet will
  // take the ownership of |permission|,
  void insert(APIPermission* permission);

  bool Contains(const APIPermissionSet& rhs) const;

  static void Difference(
      const APIPermissionSet& set1,
      const APIPermissionSet& set2,
      APIPermissionSet* set3);

  static void Intersection(
      const APIPermissionSet& set1,
      const APIPermissionSet& set2,
      APIPermissionSet* set3);

  static void Union(
      const APIPermissionSet& set1,
      const APIPermissionSet& set2,
      APIPermissionSet* set3);

  // Parses permissions from |permissions| and adds the parsed permissions to
  // |api_permissions|. If |source| is kDisallowInternalPermissions, treat
  // permissions with kFlagInternal as errors. If |unhandled_permissions|
  // is not NULL, the names of all permissions that couldn't be parsed will be
  // added to this vector. If |error| is NULL, parsing will continue with the
  // next permission if invalid data is detected. If |error| is not NULL, it
  // will be set to an error message and false is returned when an invalid
  // permission is found.
  static bool ParseFromJSON(
      const base::ListValue* permissions,
      ParseSource source,
      APIPermissionSet* api_permissions,
      string16* error,
      std::vector<std::string>* unhandled_permissions);

  void AddImpliedPermissions();

 private:
  APIPermissionMap map_;
};

}  // namespace extensions

#endif  // CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_