// 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 com.google.gerrit.common.data.AccessSection;
import com.google.gerrit.common.data.GroupReference;
import com.google.gerrit.common.data.Permission;
import com.google.gerrit.common.data.PermissionRule;
import com.google.gerrit.reviewdb.AccountGroup;
import com.google.gerrit.reviewdb.Project;
import com.google.gerrit.reviewdb.Project.SubmitType;
import com.google.gerrit.server.GerritPersonIdent;
import com.google.gerrit.server.IdentifiedUser;
import com.google.gerrit.server.account.GroupCache;
import com.google.gerrit.server.config.ProjectOwnerGroups;
import com.google.gerrit.server.git.GitRepositoryManager;
import com.google.gerrit.server.git.MetaDataUpdate;
import com.google.gerrit.server.git.ProjectConfig;
import com.google.gerrit.server.git.ReplicationQueue;
import com.google.gerrit.server.project.ProjectCache;
import com.google.gerrit.server.project.ProjectControl;
import com.google.gerrit.sshd.BaseCommand;
import com.google.inject.Inject;

import org.apache.sshd.server.Environment;
import org.eclipse.jgit.errors.ConfigInvalidException;
import org.eclipse.jgit.errors.RepositoryNotFoundException;
import org.eclipse.jgit.lib.CommitBuilder;
import org.eclipse.jgit.lib.Constants;
import org.eclipse.jgit.lib.ObjectId;
import org.eclipse.jgit.lib.ObjectInserter;
import org.eclipse.jgit.lib.PersonIdent;
import org.eclipse.jgit.lib.RefUpdate;
import org.eclipse.jgit.lib.Repository;
import org.eclipse.jgit.lib.RefUpdate.Result;
import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.Option;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/** Create a new project. **/
final class CreateProject extends BaseCommand {
  private static final Logger log = LoggerFactory.getLogger(CreateProject.class);

  @Option(name = "--name", aliases = {"-n"}, metaVar = "NAME", usage = "name of project to be created (deprecated option)")
  void setProjectNameFromOption(String name) {
    if (projectName != null) {
      throw new IllegalArgumentException("NAME already supplied");
    } else {
      projectName = name;
    }
  }

  @Option(name = "--owner", aliases = {"-o"}, usage = "owner(s) of project")
  private List<AccountGroup.UUID> ownerIds;

  @Option(name = "--parent", aliases = {"-p"}, metaVar = "NAME", usage = "parent project")
  private ProjectControl newParent;

  @Option(name = "--permissions-only", usage = "create project for use only as parent")
  private boolean permissionsOnly;

  @Option(name = "--description", aliases = {"-d"}, metaVar = "DESCRIPTION", usage = "description of project")
  private String projectDescription = "";

  @Option(name = "--submit-type", aliases = {"-t"}, usage = "project submit type\n"
      + "(default: MERGE_IF_NECESSARY)")
  private SubmitType submitType = SubmitType.MERGE_IF_NECESSARY;

  @Option(name = "--use-contributor-agreements", aliases = {"--ca"}, usage = "if contributor agreement is required")
  private boolean contributorAgreements;

  @Option(name = "--use-signed-off-by", aliases = {"--so"}, usage = "if signed-off-by is required")
  private boolean signedOffBy;

  @Option(name = "--use-content-merge", usage = "allow automatic conflict resolving within files")
  private boolean contentMerge;

  @Option(name = "--require-change-id", aliases = {"--id"}, usage = "if change-id is required")
  private boolean requireChangeID;

  @Option(name = "--branch", aliases = {"-b"}, metaVar = "BRANCH", usage = "initial branch name\n"
      + "(default: master)")
  private String branch = Constants.MASTER;

  @Option(name = "--empty-commit", usage = "to create initial empty commit")
  private boolean createEmptyCommit;

  private String projectName;
  @Argument(index = 0, metaVar="NAME", usage="name of project to be created")
  void setProjectNameFromArgument(String name) {
    if (projectName != null) {
      throw new IllegalArgumentException("--name already supplied");
    } else {
      projectName = name;
    }
  }

  @Inject
  private GitRepositoryManager repoManager;

  @Inject
  private ProjectCache projectCache;

  @Inject
  private GroupCache groupCache;

  @Inject
  @ProjectOwnerGroups
  private Set<AccountGroup.UUID> projectOwnerGroups;

  @Inject
  private IdentifiedUser currentUser;

  @Inject
  private ReplicationQueue rq;

  @Inject
  @GerritPersonIdent
  private PersonIdent serverIdent;

  @Inject
  MetaDataUpdate.User metaDataUpdateFactory;

  private Project.NameKey nameKey;

  @Override
  public void start(final Environment env) {
    startThread(new CommandRunnable() {
      @Override
      public void run() throws Exception {
        if (!currentUser.getCapabilities().canCreateProject()) {
          String msg = String.format(
            "fatal: %s does not have \"Create Project\" capability.",
            currentUser.getUserName());
          throw new UnloggedFailure(BaseCommand.STATUS_NOT_ADMIN, msg);
        }

        parseCommandLine();
        validateParameters();

        try {
          nameKey = new Project.NameKey(projectName);

          String head = permissionsOnly ? GitRepositoryManager.REF_CONFIG : branch;
          final Repository repo = repoManager.createRepository(nameKey);
          try {
            rq.replicateNewProject(nameKey, head);

            RefUpdate u = repo.updateRef(Constants.HEAD);
            u.disableRefLog();
            u.link(head);

            createProjectConfig();

            if (!permissionsOnly && createEmptyCommit) {
              createEmptyCommit(repo, nameKey, branch);
            }
          } finally {
            repo.close();
          }
        } catch (IllegalStateException err) {
          try {
            Repository repo = repoManager.openRepository(nameKey);
            try {
              if (repo.getObjectDatabase().exists()) {
                throw new UnloggedFailure(1, "fatal: project \"" + projectName + "\" exists");
              }
            } finally {
              repo.close();
            }
          } catch (RepositoryNotFoundException doesNotExist) {
            throw new Failure(1, "fatal: Cannot create " + projectName, err);
          }
        } catch (RepositoryNotFoundException badName) {
          throw new UnloggedFailure(1, "fatal: " + badName.getMessage());
        } catch (Exception err) {
          throw new Failure(1, "fatal: Cannot create " + projectName, err);
        }
      }
    });
  }

  private void createEmptyCommit(final Repository repo,
      final Project.NameKey project, final String ref) throws IOException {
    ObjectInserter oi = repo.newObjectInserter();
    try {
      CommitBuilder cb = new CommitBuilder();
      cb.setTreeId(oi.insert(Constants.OBJ_TREE, new byte[] {}));
      cb.setAuthor(metaDataUpdateFactory.getUserPersonIdent());
      cb.setCommitter(serverIdent);
      cb.setMessage("Initial empty repository\n");

      ObjectId id = oi.insert(cb);
      oi.flush();

      RefUpdate ru = repo.updateRef(Constants.HEAD);
      ru.setNewObjectId(id);
      final Result result = ru.update();
      switch (result) {
        case NEW:
          rq.scheduleUpdate(project, ref);
          break;
        default: {
          throw new IOException(result.name());
        }
      }
    } catch (IOException e) {
      log.error("Cannot create empty commit for " + projectName, e);
      throw e;
    } finally {
      oi.release();
    }
  }

  private void createProjectConfig() throws IOException, ConfigInvalidException {
    MetaDataUpdate md = metaDataUpdateFactory.create(nameKey);
    try {
      ProjectConfig config = ProjectConfig.read(md);
      config.load(md);

      Project newProject = config.getProject();
      newProject.setDescription(projectDescription);
      newProject.setSubmitType(submitType);
      newProject.setUseContributorAgreements(contributorAgreements);
      newProject.setUseSignedOffBy(signedOffBy);
      newProject.setUseContentMerge(contentMerge);
      newProject.setRequireChangeID(requireChangeID);
      if (newParent != null) {
        newProject.setParentName(newParent.getProject().getName());
      }

      if (!ownerIds.isEmpty()) {
        AccessSection all = config.getAccessSection(AccessSection.ALL, true);
        for (AccountGroup.UUID ownerId : ownerIds) {
          AccountGroup accountGroup = groupCache.get(ownerId);
          GroupReference group = config.resolve(accountGroup);
          all.getPermission(Permission.OWNER, true).add(
              new PermissionRule(group));
        }
      }

      md.setMessage("Created project\n");
      if (!config.commit(md)) {
        throw new IOException("Cannot create " + projectName);
      }
    } finally {
      md.close();
    }
    projectCache.onCreateProject(nameKey);
    repoManager.setProjectDescription(nameKey, projectDescription);
    rq.scheduleUpdate(nameKey, GitRepositoryManager.REF_CONFIG);
  }

  private void validateParameters() throws Failure {
    if (projectName == null || projectName.isEmpty()) {
      throw new Failure(1, "fatal: Argument NAME is required");
    }

    if (projectName.endsWith(Constants.DOT_GIT_EXT)) {
      projectName = projectName.substring(0, //
          projectName.length() - Constants.DOT_GIT_EXT.length());
    }

    if (ownerIds != null && !ownerIds.isEmpty()) {
      ownerIds =
          new ArrayList<AccountGroup.UUID>(new HashSet<AccountGroup.UUID>(ownerIds));
    } else {
      ownerIds = new ArrayList<AccountGroup.UUID>(projectOwnerGroups);
    }

    while (branch.startsWith("/")) {
      branch = branch.substring(1);
    }
    if (!branch.startsWith(Constants.R_HEADS)) {
      branch = Constants.R_HEADS + branch;
    }
    if (!Repository.isValidRefName(branch)) {
      throw new Failure(1, "--branch \"" + branch + "\" is not a valid name");
    }
  }
}