/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements. See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership. The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at
    *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied. See the License for the
   * specific language governing permissions and limitations under the License.
   */
  
  package org.apache.shindig.social.sample.spi;
  
  import org.apache.shindig.auth.SecurityToken;
  import org.apache.shindig.common.util.ImmediateFuture;
  import org.apache.shindig.common.util.ResourceLoader;
  import org.apache.shindig.social.ResponseError;
  import org.apache.shindig.social.opensocial.model.Activity;
  import org.apache.shindig.social.opensocial.model.Person;
  import org.apache.shindig.social.opensocial.service.BeanConverter;
  import org.apache.shindig.social.opensocial.spi.ActivityService;
  import org.apache.shindig.social.opensocial.spi.AppDataService;
  import org.apache.shindig.social.opensocial.spi.CollectionOptions;
  import org.apache.shindig.social.opensocial.spi.DataCollection;
  import org.apache.shindig.social.opensocial.spi.GroupId;
  import org.apache.shindig.social.opensocial.spi.PersonService;
  import org.apache.shindig.social.opensocial.spi.RestfulCollection;
  import org.apache.shindig.social.opensocial.spi.SocialSpiException;
  import org.apache.shindig.social.opensocial.spi.UserId;
  
  import com.google.common.collect.ImmutableSortedSet;
  import com.google.common.collect.Lists;
  import com.google.common.collect.Maps;
  import com.google.common.collect.Sets;
  import com.google.inject.Inject;
  import com.google.inject.Singleton;
  import com.google.inject.name.Named;
  
  import org.apache.commons.io.IOUtils;
  import org.json.JSONArray;
  import org.json.JSONException;
  import org.json.JSONObject;
  
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.concurrent.Future;
  
  /***
   * Implementation of supported services backed by a JSON DB.
   */
  @Singleton
  public class JsonDbOpensocialService implements ActivityService, PersonService, AppDataService {
  
    private static final Comparator<Person> NAME_COMPARATOR = new Comparator<Person>() {
      public int compare(Person person, Person person1) {
        String name = person.getName().getUnstructured();
        String name1 = person1.getName().getUnstructured();
        return name.compareTo(name1);
      }
    };
  
    /***
     * The DB
     */
    private JSONObject db;
  
    /***
     * The JSON<->Bean converter
     */
    private BeanConverter converter;
  
    /***
     * db["activities"] -> Array<Person>
     */
    private static final String PEOPLE_TABLE = "people";
  
    /***
     * db["people"] -> Map<Person.Id, Array<Activity>>
     */
    private static final String ACTIVITIES_TABLE = "activities";
  
    /***
     * db["data"] -> Map<Person.Id, Map<String, String>>
     */
    private static final String DATA_TABLE = "data";
  
    /***
     * db["friendLinks"] -> Map<Person.Id, Array<Person.Id>>
    */
   private static final String FRIEND_LINK_TABLE = "friendLinks";
 
   @Inject
   public JsonDbOpensocialService(@Named("shindig.canonical.json.db")String jsonLocation,
       @Named("shindig.bean.converter.json")BeanConverter converter) throws Exception {
     String content = IOUtils.toString(ResourceLoader.openResource(jsonLocation), "UTF-8");
     this.db = new JSONObject(content);
     this.converter = converter;
   }
 
   public JSONObject getDb() {
     return db;
   }
 
   public void setDb(JSONObject db) {
     this.db = db;
   }
 
   public Future<RestfulCollection<Activity>> getActivities(Set<UserId> userIds,
       GroupId groupId, String appId, Set<String> fields, SecurityToken token)
       throws SocialSpiException  {
     List<Activity> result = Lists.newArrayList();
     try {
       Set<String> idSet = getIdSet(userIds, groupId, token);
       for (String id : idSet) {
         if (db.getJSONObject(ACTIVITIES_TABLE).has(id)) {
           JSONArray activities = db.getJSONObject(ACTIVITIES_TABLE).getJSONArray(id);
           for (int i = 0; i < activities.length(); i++) {
             JSONObject activity = activities.getJSONObject(i);
             if (appId == null || !activity.has(Activity.Field.APP_ID.toString())) {
               result.add(convertToActivity(activity, fields));
             } else if (activity.get(Activity.Field.APP_ID.toString()).equals(appId)) {
               result.add(convertToActivity(activity, fields));
             }
           }
         }
       }
       return ImmediateFuture.newInstance(new RestfulCollection<Activity>(result));
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<RestfulCollection<Activity>> getActivities(UserId userId,
       GroupId groupId, String appId, Set<String> fields,
       Set<String> activityIds, SecurityToken token) throws SocialSpiException {
     List<Activity> result = Lists.newArrayList();
     try {
       String user = userId.getUserId(token);
       if (db.getJSONObject(ACTIVITIES_TABLE).has(user)) {
         JSONArray activities = db.getJSONObject(ACTIVITIES_TABLE).getJSONArray(user);
         for (int i = 0; i < activities.length(); i++) {
           JSONObject activity = activities.getJSONObject(i);
           if (activity.get(Activity.Field.USER_ID.toString()).equals(user)
               && activityIds.contains(activity.getString(Activity.Field.ID.toString()))) {
             result.add(convertToActivity(activity, fields));
           }
         }
       }
       return ImmediateFuture.newInstance(new RestfulCollection<Activity>(result));
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<Activity> getActivity(UserId userId,
       GroupId groupId, String appId, Set<String> fields, String activityId, SecurityToken token)
       throws SocialSpiException {
     try {
       String user = userId.getUserId(token);
       if (db.getJSONObject(ACTIVITIES_TABLE).has(user)) {
         JSONArray activities = db.getJSONObject(ACTIVITIES_TABLE).getJSONArray(user);
         for (int i = 0; i < activities.length(); i++) {
           JSONObject activity = activities.getJSONObject(i);
           if (activity.get(Activity.Field.USER_ID.toString()).equals(user)
               && activity.get(Activity.Field.ID.toString()).equals(activityId)) {
             return ImmediateFuture.newInstance(convertToActivity(activity, fields));
           }
         }
       }
 
       throw new SocialSpiException(ResponseError.BAD_REQUEST, "Activity not found");
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<Void> deleteActivities(UserId userId, GroupId groupId, String appId,
       Set<String> activityIds, SecurityToken token) throws SocialSpiException {
     try {
       String user = userId.getUserId(token);
       if (db.getJSONObject(ACTIVITIES_TABLE).has(user)) {
         JSONArray activities = db.getJSONObject(ACTIVITIES_TABLE).getJSONArray(user);
         if (activities != null) {
           JSONArray newList = new JSONArray();
           for (int i = 0; i < activities.length(); i++) {
             JSONObject activity = activities.getJSONObject(i);
             if (!activityIds.contains(activity.getString(Activity.Field.ID.toString()))) {
               newList.put(activity);
             }
           }
           db.getJSONObject(ACTIVITIES_TABLE).put(user, newList);
           // TODO. This seems very odd that we return no useful response in this case
           // There is no way to represent not-found
           // if (found) { ??
           //}
         }
       }
       // What is the appropriate response here??
       return ImmediateFuture.newInstance(null);
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<Void> createActivity(UserId userId, GroupId groupId, String appId,
       Set<String> fields, Activity activity, SecurityToken token) throws SocialSpiException {
     // Are fields really needed here?
     try {
       JSONObject jsonObject = convertFromActivity(activity, fields);
       if (!jsonObject.has(Activity.Field.ID.toString())) {
         jsonObject.put(Activity.Field.ID.toString(), System.currentTimeMillis());
       }
       JSONArray jsonArray = db.getJSONObject(ACTIVITIES_TABLE)
           .getJSONArray(userId.getUserId(token));
       if (jsonArray == null) {
         jsonArray = new JSONArray();
         db.getJSONObject(ACTIVITIES_TABLE).put(userId.getUserId(token), jsonArray);
       }
       jsonArray.put(jsonObject);
       return ImmediateFuture.newInstance(null);
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<RestfulCollection<Person>> getPeople(Set<UserId> userIds,
       GroupId groupId, CollectionOptions options, Set<String> fields, SecurityToken token)
       throws SocialSpiException {
     List<Person> result = Lists.newArrayList();
     try {
       JSONArray people = db.getJSONArray(PEOPLE_TABLE);
 
       Set<String> idSet = getIdSet(userIds, groupId, token);
 
       for (int i = 0; i < people.length(); i++) {
         JSONObject person = people.getJSONObject(i);
         if (!idSet.contains(person.get(Person.Field.ID.toString()))) {
           continue;
         }
         // Add group support later
         result.add(convertToPerson(person, fields));
       }
 
       // We can pretend that by default the people are in top friends order
       if (options.getSortBy().equals(Person.Field.NAME.toString())) {
         Collections.sort(result, NAME_COMPARATOR);
       }
 
       if (options.getSortOrder().equals(SortOrder.descending)) {
         Collections.reverse(result);
       }
 
       // TODO: The samplecontainer doesn't really have the concept of HAS_APP so
       // we can't support any filters yet. We should fix this.
 
       int totalSize = result.size();
       int last = options.getFirst() + options.getMax();
       result = result.subList(options.getFirst(), Math.min(last, totalSize));
 
       return ImmediateFuture.newInstance(new RestfulCollection<Person>(
           result, options.getFirst(), totalSize));
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<Person> getPerson(UserId id, Set<String> fields,
       SecurityToken token) throws SocialSpiException {
     try {
       JSONArray people = db.getJSONArray(PEOPLE_TABLE);
 
       for (int i = 0; i < people.length(); i++) {
         JSONObject person = people.getJSONObject(i);
         if (id != null && person.get(Person.Field.ID.toString())
             .equals(id.getUserId(token))) {
           return ImmediateFuture.newInstance(convertToPerson(person, fields));
         }
       }
       throw new SocialSpiException(ResponseError.BAD_REQUEST, "Person not found");
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<DataCollection> getPersonData(Set<UserId> userIds, GroupId groupId,
       String appId, Set<String> fields, SecurityToken token) throws SocialSpiException {
     try {
       Map<String, Map<String, String>> idToData = Maps.newHashMap();
       Set<String> idSet = getIdSet(userIds, groupId, token);
       for (String id : idSet) {
         JSONObject personData;
         if (!db.getJSONObject(DATA_TABLE).has(id)) {
           personData = new JSONObject();
         } else {
           if (!fields.isEmpty()) {
             personData = new JSONObject(
                 db.getJSONObject(DATA_TABLE).getJSONObject(id),
                 fields.toArray(new String[fields.size()]));
           } else {
             personData = db.getJSONObject(DATA_TABLE).getJSONObject(id);
           }
         }
 
         // TODO: We can use the converter here to do this for us
         Iterator keys = personData.keys();
         Map<String, String> data = Maps.newHashMap();
         while (keys.hasNext()) {
           String key = (String) keys.next();
           data.put(key, personData.getString(key));
         }
         idToData.put(id, data);
       }
       return ImmediateFuture.newInstance(new DataCollection(idToData));
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<Void> deletePersonData(UserId userId, GroupId groupId, String appId,
       Set<String> fields, SecurityToken token) throws SocialSpiException {
     try {
       String user = userId.getUserId(token);
       if (!db.getJSONObject(DATA_TABLE).has(user)) {
         return null;
       }
       JSONObject newPersonData = new JSONObject();
       JSONObject oldPersonData = db.getJSONObject(DATA_TABLE).getJSONObject(user);
       Iterator keys = oldPersonData.keys();
       while (keys.hasNext()) {
         String key = (String) keys.next();
         if (!fields.contains(key)) {
           newPersonData.put(key, oldPersonData.getString(key));
         }
       }
       db.getJSONObject(DATA_TABLE).put(user, newPersonData);
       return ImmediateFuture.newInstance(null);
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   public Future<Void> updatePersonData(UserId userId, GroupId groupId, String appId,
       Set<String> fields, Map<String, String> values, SecurityToken token)
       throws SocialSpiException {
     // TODO: this seems redundant. No need to pass both fields and a map of field->value
     // TODO: According to rest, yes there is. If a field is in the param list but not in the map
     // that means it is a delete
 
     try {
       JSONObject personData = db.getJSONObject(DATA_TABLE).getJSONObject(userId.getUserId(token));
       if (personData == null) {
         personData = new JSONObject();
         db.getJSONObject(DATA_TABLE).put(userId.getUserId(token), personData);
       }
 
       for (Map.Entry<String, String> entry : values.entrySet()) {
         personData.put(entry.getKey(), entry.getValue());
       }
       return ImmediateFuture.newInstance(null);
     } catch (JSONException je) {
       throw new SocialSpiException(ResponseError.INTERNAL_ERROR, je.getMessage(), je);
     }
   }
 
   /***
    * Get the set of user id's from a user and group
    */
   private Set<String> getIdSet(UserId user, GroupId group, SecurityToken token)
       throws JSONException {
     String userId = user.getUserId(token);
 
     if (group == null) {
       return ImmutableSortedSet.of(userId);
     }
 
     Set<String> returnVal = Sets.newLinkedHashSet();
     switch (group.getType()) {
       case all:
       case friends:
       case groupId:
         if (db.getJSONObject(FRIEND_LINK_TABLE).has(userId)) {
           JSONArray friends = db.getJSONObject(FRIEND_LINK_TABLE).getJSONArray(userId);
           for (int i = 0; i < friends.length(); i++) {
             returnVal.add(friends.getString(i));
           }
         }
         break;
       case self:
         returnVal.add(userId);
         break;
     }
     return returnVal;
   }
 
   /***
    * Get the set of user id's for a set of users and a group
    */
   private Set<String> getIdSet(Set<UserId> users, GroupId group, SecurityToken token)
       throws JSONException {
     Set<String> ids = Sets.newLinkedHashSet();
     for (UserId user : users) {
       ids.addAll(getIdSet(user, group, token));
     }
     return ids;
   }
 
   private Activity convertToActivity(JSONObject object, Set<String> fields) throws JSONException {
     if (!fields.isEmpty()) {
       // Create a copy with just the specified fields
       object = new JSONObject(object, fields.toArray(new String[fields.size()]));
     }
     return converter.convertToObject(object.toString(), Activity.class);
   }
 
   private JSONObject convertFromActivity(Activity activity, Set<String> fields)
       throws JSONException {
     // TODO Not using fields yet
     return new JSONObject(converter.convertToString(activity));
   }
 
   private Person convertToPerson(JSONObject object, Set<String> fields) throws JSONException {
     if (!fields.isEmpty()) {
       // Create a copy with just the specified fields
       object = new JSONObject(object, fields.toArray(new String[fields.size()]));
     }
     return converter.convertToObject(object.toString(), Person.class);
   }
 }