/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

package org.mozilla.gecko.sync;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.mozilla.gecko.R;
import org.mozilla.gecko.background.common.log.Logger;
import org.mozilla.gecko.sync.repositories.NullCursorException;
import org.mozilla.gecko.sync.repositories.android.ClientsDatabaseAccessor;
import org.mozilla.gecko.sync.repositories.domain.ClientRecord;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;

/**
 * Process commands received from Sync clients.
 * <p>
 * We need a command processor at two different times:
 * <ol>
 * <li>We execute commands during the "clients" engine stage of a Sync. Each
 * command takes a <code>GlobalSession</code> instance as a parameter.</li>
 * <li>We queue commands to be executed or propagated to other Sync clients
 * during an activity completely unrelated to a sync (such as
 * <code>SendTabActivity</code>.)</li>
 * </ol>
 * To provide a processor for both these time frames, we maintain a static
 * long-lived singleton.
 */
public class CommandProcessor {
  private static final String LOG_TAG = "Command";
  private static AtomicInteger currentId = new AtomicInteger();
  protected ConcurrentHashMap<String, CommandRunner> commands = new ConcurrentHashMap<String, CommandRunner>();

  private final static CommandProcessor processor = new CommandProcessor();

  /**
   * Get the global singleton command processor.
   *
   * @return the singleton processor.
   */
  public static CommandProcessor getProcessor() {
    return processor;
  }

  public static class Command {
    public final String commandType;
    public final JSONArray args;
    private List<String> argsList;

    public Command(String commandType, JSONArray args) {
      this.commandType = commandType;
      this.args = args;
    }

    /**
     * Get list of arguments as strings.  Individual arguments may be null.
     *
     * @return list of strings.
     */
    public synchronized List<String> getArgsList() {
      if (argsList == null) {
        ArrayList<String> argsList = new ArrayList<String>(args.size());

        for (int i = 0; i < args.size(); i++) {
          final Object arg = args.get(i);
          if (arg == null) {
            argsList.add(null);
            continue;
          }
          argsList.add(arg.toString());
        }
        this.argsList = argsList;
      }
      return this.argsList;
    }

    @SuppressWarnings("unchecked")
    public JSONObject asJSONObject() {
      JSONObject out = new JSONObject();
      out.put("command", this.commandType);
      out.put("args", this.args);
      return out;
    }
  }

  /**
   * Register a command.
   * <p>
   * Any existing registration is overwritten.
   *
   * @param commandType
   *          the name of the command, i.e., "displayURI".
   * @param command
   *          the <code>CommandRunner</code> instance that should handle the
   *          command.
   */
  public void registerCommand(String commandType, CommandRunner command) {
    commands.put(commandType, command);
  }

  /**
   * Process a command in the context of the given global session.
   *
   * @param session
   *          the <code>GlobalSession</code> instance currently executing.
   * @param unparsedCommand
   *          command as a <code>ExtendedJSONObject</code> instance.
   */
  public void processCommand(final GlobalSession session, ExtendedJSONObject unparsedCommand) {
    Command command = parseCommand(unparsedCommand);
    if (command == null) {
      Logger.debug(LOG_TAG, "Invalid command: " + unparsedCommand + " will not be processed.");
      return;
    }

    CommandRunner executableCommand = commands.get(command.commandType);
    if (executableCommand == null) {
      Logger.debug(LOG_TAG, "Command \"" + command.commandType + "\" not registered and will not be processed.");
      return;
    }

    executableCommand.executeCommand(session, command.getArgsList());
  }

  /**
   * Parse a JSON command into a ParsedCommand object for easier handling.
   *
   * @param unparsedCommand - command as ExtendedJSONObject
   * @return - null if command is invalid, else return ParsedCommand with
   *           no null attributes.
   */
  protected static Command parseCommand(ExtendedJSONObject unparsedCommand) {
    String type = (String) unparsedCommand.get("command");
    if (type == null) {
      return null;
    }

    try {
      JSONArray unparsedArgs = unparsedCommand.getArray("args");
      if (unparsedArgs == null) {
        return null;
      }

      return new Command(type, unparsedArgs);
    } catch (NonArrayJSONException e) {
      Logger.debug(LOG_TAG, "Unable to parse args array. Invalid command");
      return null;
    }
  }

  @SuppressWarnings("unchecked")
  public void sendURIToClientForDisplay(String uri, String clientID, String title, String sender, Context context) {
    Logger.info(LOG_TAG, "Sending URI to client " + clientID + ".");
    if (Logger.LOG_PERSONAL_INFORMATION) {
      Logger.pii(LOG_TAG, "URI is " + uri + "; title is '" + title + "'.");
    }

    final JSONArray args = new JSONArray();
    args.add(uri);
    args.add(sender);
    args.add(title);

    final Command displayURICommand = new Command("displayURI", args);
    this.sendCommand(clientID, displayURICommand, context);
  }

  /**
   * Validates and sends a command to a client or all clients.
   *
   * Calling this does not actually sync the command data to the server. If the
   * client already has the command/args pair, it won't receive a duplicate
   * command.
   *
   * @param clientID
   *        Client ID to send command to. If null, send to all remote
   *        clients.
   * @param command
   *        Command to invoke on remote clients
   */
  public void sendCommand(String clientID, Command command, Context context) {
    Logger.debug(LOG_TAG, "In sendCommand.");

    CommandRunner commandData = commands.get(command.commandType);

    // Don't send commands that we don't know about.
    if (commandData == null) {
      Logger.error(LOG_TAG, "Unknown command to send: " + command);
      return;
    }

    // Don't send a command with the wrong number of arguments.
    if (!commandData.argumentsAreValid(command.getArgsList())) {
      Logger.error(LOG_TAG, "Expected " + commandData.argCount + " args for '" +
                   command + "', but got " + command.args);
      return;
    }

    if (clientID != null) {
      this.sendCommandToClient(clientID, command, context);
      return;
    }

    ClientsDatabaseAccessor db = new ClientsDatabaseAccessor(context);
    try {
      Map<String, ClientRecord> clientMap = db.fetchAllClients();
      for (ClientRecord client : clientMap.values()) {
        this.sendCommandToClient(client.guid, command, context);
      }
    } catch (NullCursorException e) {
      Logger.error(LOG_TAG, "NullCursorException when fetching all GUIDs");
    } finally {
      db.close();
    }
  }

  protected void sendCommandToClient(String clientID, Command command, Context context) {
    Logger.info(LOG_TAG, "Sending " + command.commandType + " to " + clientID);

    ClientsDatabaseAccessor db = new ClientsDatabaseAccessor(context);
    try {
      db.store(clientID, command);
    } catch (NullCursorException e) {
      Logger.error(LOG_TAG, "NullCursorException: Unable to send command.");
    } finally {
      db.close();
    }
  }

  public static void displayURI(final List<String> args, final Context context) {
    // We trust the client sender that these exist.
    final String uri = args.get(0);
    final String clientId = args.get(1);

    Logger.pii(LOG_TAG, "Received a URI for display: " + uri + " from " + clientId);

    String title = null;
    if (args.size() == 3) {
      title = args.get(2);
    }

    final String ns = Context.NOTIFICATION_SERVICE;
    final NotificationManager notificationManager = (NotificationManager) context.getSystemService(ns);

    // Create a Notificiation.
    final int icon = R.drawable.icon;
    String notificationTitle = context.getString(R.string.sync_new_tab);
    if (title != null) {
      notificationTitle = notificationTitle.concat(": " + title);
    }

    final long when = System.currentTimeMillis();
    Notification notification = new Notification(icon, notificationTitle, when);
    notification.flags = Notification.FLAG_AUTO_CANCEL;

    // Set pending intent associated with the notification.
    Intent notificationIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(uri));
    PendingIntent contentIntent = PendingIntent.getActivity(context, 0, notificationIntent, 0);
    notification.setLatestEventInfo(context, notificationTitle, uri, contentIntent);

    // Send notification.
    notificationManager.notify(currentId.getAndIncrement(), notification);
  }
}
