// Copyright (C) 2009 The Android Open Source Project
//
// Licensed 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 com.google.gerrit.sshd.commands;

import static com.google.gerrit.sshd.CommandMetaData.Mode.MASTER_OR_SLAVE;

import com.google.common.base.Objects;
import com.google.gerrit.reviewdb.client.Project;
import com.google.gerrit.server.IdentifiedUser;
import com.google.gerrit.server.git.TaskInfoFactory;
import com.google.gerrit.server.git.WorkQueue;
import com.google.gerrit.server.git.WorkQueue.ProjectTask;
import com.google.gerrit.server.git.WorkQueue.Task;
import com.google.gerrit.server.project.ProjectCache;
import com.google.gerrit.server.project.ProjectState;
import com.google.gerrit.server.util.IdGenerator;
import com.google.gerrit.server.util.TimeUtil;
import com.google.gerrit.sshd.AdminHighPriorityCommand;
import com.google.gerrit.sshd.CommandMetaData;
import com.google.gerrit.sshd.SshCommand;
import com.google.inject.Inject;

import org.apache.sshd.server.Environment;
import org.kohsuke.args4j.Option;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

/** Display the current work queue. */
@AdminHighPriorityCommand
@CommandMetaData(name = "show-queue", description = "Display the background work queues",
  runsAt = MASTER_OR_SLAVE)
final class ShowQueue extends SshCommand {
  @Option(name = "--wide", aliases = {"-w"}, usage = "display without line width truncation")
  private boolean wide;

  @Inject
  private WorkQueue workQueue;

  @Inject
  private ProjectCache projectCache;

  @Inject
  private IdentifiedUser currentUser;

  private int columns = 80;
  private int taskNameWidth;

  @Override
  public void start(final Environment env) throws IOException {
    String s = env.getEnv().get(Environment.ENV_COLUMNS);
    if (s != null && !s.isEmpty()) {
      try {
        columns = Integer.parseInt(s);
      } catch (NumberFormatException err) {
        columns = 80;
      }
    }
    super.start(env);
  }

  @Override
  protected void run() {
    taskNameWidth = wide ? Integer.MAX_VALUE : columns - 8 - 12 - 12 - 4 - 4;
    final List<QueueTaskInfo> pending = getSortedTaskInfoList();

    stdout.print(String.format("%-8s %-12s %-12s %-4s %s\n", //
        "Task", "State", "StartTime", "", "Command"));
    stdout.print("----------------------------------------------"
        + "--------------------------------\n");

    int numberOfPendingTasks = 0;
    final long now = TimeUtil.nowMs();
    final boolean viewAll = currentUser.getCapabilities().canViewQueue();

    for (final QueueTaskInfo taskInfo : pending) {
      final long delay = taskInfo.delayMillis;
      final Task.State state = taskInfo.state;

      final String start;
      switch (state) {
        case DONE:
        case CANCELLED:
        case RUNNING:
        case READY:
          start = format(state);
          break;
        default:
          start = time(now, delay);
          break;
      }

      boolean regularUserCanSee = false;
      boolean hasCustomizedPrint = true;

      // If the user is not administrator, check if has rights to see
      // the Task
      Project.NameKey projectName = null;
      String remoteName = null;

      if (!viewAll) {
        projectName = taskInfo.getProjectNameKey();
        remoteName = taskInfo.getRemoteName();
        hasCustomizedPrint = taskInfo.hasCustomizedPrint();

        ProjectState e = null;
        if (projectName != null) {
          e = projectCache.get(projectName);
        }

        regularUserCanSee = e != null && e.controlFor(currentUser).isVisible();

        if (regularUserCanSee) {
          numberOfPendingTasks++;
        }
      }

      String startTime = startTime(taskInfo.getStartTime());

      // Shows information about tasks depending on the user rights
      if (viewAll || (!hasCustomizedPrint && regularUserCanSee)) {
        stdout.print(String.format("%8s %-12s %-12s %-4s %s\n", //
            id(taskInfo.getTaskId()), start, startTime, "",
            taskInfo.getTaskString(taskNameWidth)));
      } else if (regularUserCanSee) {
        if (projectName != null) {
          if (remoteName == null) {
            remoteName = projectName.get();
          } else {
            remoteName = remoteName + "/" + projectName.get();
          }
        }

        stdout.print(String.format("%8s %-12s %-4s %s\n",
            id(taskInfo.getTaskId()), start, startTime,
            Objects.firstNonNull(remoteName, "n/a")));
      }
    }
    stdout.print("----------------------------------------------"
        + "--------------------------------\n");

    if (viewAll) {
      numberOfPendingTasks = pending.size();
    }

    stdout.print("  " + numberOfPendingTasks + " tasks\n");
  }

  private List<QueueTaskInfo> getSortedTaskInfoList() {
    final List<QueueTaskInfo> taskInfos =
        workQueue.getTaskInfos(new TaskInfoFactory<QueueTaskInfo>() {
          @Override
          public QueueTaskInfo getTaskInfo(Task<?> task) {
            return new QueueTaskInfo(task);
          }
        });
    Collections.sort(taskInfos, new Comparator<QueueTaskInfo>() {
      @Override
      public int compare(QueueTaskInfo a, QueueTaskInfo b) {
        if (a.state != b.state) {
          return a.state.ordinal() - b.state.ordinal();
        }

        int cmp = Long.signum(a.delayMillis - b.delayMillis);
        if (cmp != 0) {
          return cmp;
        }

        return a.getTaskString(taskNameWidth)
            .compareTo(b.getTaskString(taskNameWidth));
      }
    });
    return taskInfos;
  }

  private static String id(final int id) {
    return IdGenerator.format(id);
  }

  private static String time(final long now, final long delay) {
    final Date when = new Date(now + delay);
    return format(when, delay);
  }

  private static String startTime(final Date when) {
    return format(when, TimeUtil.nowMs() - when.getTime());
  }

  private static String format(final Date when, final long timeFromNow) {
    if (timeFromNow < 24 * 60 * 60 * 1000L) {
      return new SimpleDateFormat("HH:mm:ss.SSS").format(when);
    }
    return new SimpleDateFormat("MMM-dd HH:mm").format(when);
  }

  private static String format(final Task.State state) {
    switch (state) {
      case DONE:
        return "....... done";
      case CANCELLED:
        return "..... killed";
      case RUNNING:
        return "";
      case READY:
        return "waiting ....";
      case SLEEPING:
        return "sleeping";
      default:
        return state.toString();
    }
  }

  private static class QueueTaskInfo {
    private final long delayMillis;
    private final Task.State state;
    private final Task<?> task;

    QueueTaskInfo(Task<?> task) {
      this.task = task;
      this.delayMillis = task.getDelay(TimeUnit.MILLISECONDS);
      this.state = task.getState();
    }

    String getRemoteName() {
      if (task instanceof ProjectTask) {
        return ((ProjectTask<?>) task).getRemoteName();
      }
      return null;
    }

    Project.NameKey getProjectNameKey() {
      if (task instanceof ProjectTask<?>) {
        return ((ProjectTask<?>) task).getProjectNameKey();
      }
      return null;
    }

    boolean hasCustomizedPrint() {
      if (task instanceof ProjectTask<?>) {
        return ((ProjectTask<?>) task).hasCustomizedPrint();
      }
      return false;
    }

    int getTaskId() {
      return task.getTaskId();
    }

    Date getStartTime() {
      return task.getStartTime();
    }

    String getTaskString(int maxLength) {
      String s = task.toString();
      return s.length() < maxLength ? s : s.substring(0, maxLength);
    }
  }
}