/*
 * Copyright 2017 HugeGraph Authors
 *
 * 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 com.baidu.hugegraph.cmd;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang3.StringUtils;

import com.baidu.hugegraph.api.API;
import com.baidu.hugegraph.constant.AuthRestoreConflictStrategy;
import com.baidu.hugegraph.manager.TasksManager;
import com.baidu.hugegraph.structure.constant.GraphMode;
import com.baidu.hugegraph.structure.constant.HugeType;
import com.baidu.hugegraph.util.E;
import com.baidu.hugegraph.util.InsertionOrderUtil;
import com.beust.jcommander.DynamicParameter;
import com.beust.jcommander.IParameterValidator;
import com.beust.jcommander.IStringConverter;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;
import com.beust.jcommander.Parameters;
import com.beust.jcommander.ParametersDelegate;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;

public class SubCommands {

    private Map<String, Object> commands;

    public SubCommands() {
        this.commands = InsertionOrderUtil.newMap();
        this.initSubCommands();
    }

    private void initSubCommands() {
        this.commands.put("graph-create", new GraphCreate());
        this.commands.put("graph-clone", new GraphClone());
        this.commands.put("graph-list", new GraphList());
        this.commands.put("graph-get", new GraphGet());
        this.commands.put("graph-clear", new GraphClear());
        this.commands.put("graph-drop", new GraphDrop());
        this.commands.put("graph-mode-set", new GraphModeSet());
        this.commands.put("graph-mode-get", new GraphModeGet());

        this.commands.put("task-list", new TaskList());
        this.commands.put("task-get", new TaskGet());
        this.commands.put("task-delete", new TaskDelete());
        this.commands.put("task-cancel", new TaskCancel());
        this.commands.put("task-clear", new TaskClear());

        this.commands.put("gremlin-execute", new Gremlin());
        this.commands.put("gremlin-schedule", new GremlinJob());

        this.commands.put("backup", new Backup());
        this.commands.put("schedule-backup", new ScheduleBackup());
        this.commands.put("dump", new DumpGraph());
        this.commands.put("restore", new Restore());
        this.commands.put("migrate", new Migrate());

        this.commands.put("deploy", new Deploy());
        this.commands.put("start-all", new StartAll());
        this.commands.put("clear", new Clear());
        this.commands.put("stop-all", new StopAll());

        this.commands.put("auth-backup", new AuthBackup());
        this.commands.put("auth-restore", new AuthRestore());

        this.commands.put("help", new Help());
    }

    public Map<String, Object> commands() {
        return this.commands;
    }

    @Parameters(commandDescription = "Schedule backup task")
    public static class ScheduleBackup {

        @Parameter(names = {"--interval"}, arity = 1,
                   description =
                           "The interval of backup, format is: \"a b c d e\"." +
                           " 'a' means minute (0 - 59)," +
                           " 'b' means hour (0 - 23)," +
                           " 'c' means day of month (1 - 31)," +
                           " 'd' means month (1 - 12)," +
                           " 'e' means day of week (0 - 6) (Sunday=0)," +
                           " \"*\" means all")
        public String interval = "\"0 0 * * *\"";

        @Parameter(names = {"--backup-num"}, arity = 1,
                   description = "The number of latest backups to keep")
        public int num = 3;

        @Parameter(names = {"--directory", "-d"}, arity = 1, required = true,
                   description = "The directory of backups stored")
        public String directory;
    }

    @Parameters(commandDescription = "Backup graph schema/data. If directory " +
                                     "is on HDFS, use -D to set HDFS params. " +
                                     "For example: " +
                                     "-Dfs.default.name=hdfs://localhost:9000")
    public static class Backup extends BackupRestore {

        @Parameter(names = {"--split-size", "-s"}, arity = 1,
                   description = "Split size of shard")
        public long splitSize = 1024 * 1024L;

        @ParametersDelegate
        private HugeTypes types = new HugeTypes();

        @Parameter(names = {"--format"}, arity = 1,
                   validateWith = {FormatValidator.class},
                   description = "File format, valid is [json, text]")
        public String format = "json";

        @Parameter(names = {"--compress"}, arity = 1,
                   description = "compress flag")
        public boolean compress = true;

        @Parameter(names = {"--label"}, arity = 1,
                   description = "Vertex label or edge label, only valid when type " +
                                 "is vertex or edge")
        public String label;

        @Parameter(names = {"--all-properties"}, arity = 1,
                   description = "All properties to be backup flag")
        public boolean allProperties = false;

        @Parameter(names = {"--properties"}, arity = 1,
                   description = "Vertex or edge properties to backup, " +
                                 "only valid when type is vertex or edge")
        public List<String> properties = ImmutableList.of();

        public long splitSize() {
            return this.splitSize;
        }

        public void splitSize(long splitSize) {
            this.splitSize = splitSize;
        }

        public List<HugeType> types() {
            return this.types.types;
        }

        public void types(List<HugeType> types) {
            this.types.types = types;
        }

        public String format() {
            return this.format;
        }

        public void format(String format) {
            this.format = format;
        }

        public boolean compress() {
            return this.compress;
        }

        public void compress(boolean compress) {
            this.compress = compress;
        }

        public String label() {
            return this.label;
        }

        public void label(String label) {
            this.label = label;
        }

        public boolean allProperties() {
            return this.allProperties;
        }

        public void allProperties(boolean allProperties) {
            this.allProperties = allProperties;
        }

        public List<String> properties() {
            return this.properties;
        }

        public void properties(List<String> properties) {
            this.properties = properties;
        }
    }

    @Parameters(commandDescription = "Restore graph schema/data. If directory" +
                                     " is on HDFS, use -D to set HDFS params " +
                                     "if needed. For example:" +
                                     "-Dfs.default.name=hdfs://localhost:9000")
    public static class Restore extends BackupRestore {
        @Parameter(names = {"--clean"},
                   description = "Whether to remove the directory of " +
                                 "graph data after restored")
        public boolean clean = false;

        @ParametersDelegate
        private HugeTypes types = new HugeTypes();

        public boolean clean() {
            return this.clean;
        }

        public void clean(boolean clean) {
            this.clean = clean;
        }

        public List<HugeType> types() {
            return this.types.types;
        }

        public void types(List<HugeType> types) {
            this.types.types = types;
        }
    }

    @Parameters(commandDescription = "Dump graph to files")
    public static class DumpGraph extends BackupRestore {

        @Parameter(names = {"--formatter", "-f"}, arity = 1,
                   description = "Formatter to customize format of vertex/edge")
        public String formatter = "JsonFormatter";

        @Parameter(names = {"--split-size", "-s"}, arity = 1,
                   description = "Split size of shard")
        public long splitSize = 1024 * 1024L;

        public String formatter() {
            return this.formatter;
        }

        public long splitSize() {
            return this.splitSize;
        }

        public void splitSize(long splitSize) {
            this.splitSize = splitSize;
        }
    }

    @Parameters(commandDescription = "Migrate graph")
    public static class Migrate extends BackupRestore {

        @Parameter(names = {"--split-size", "-s"}, arity = 1,
                   description = "Split size of shard")
        public long splitSize = 1024 * 1024L;

        @ParametersDelegate
        private HugeTypes types = new HugeTypes();

        @Parameter(names = {"--target-url"}, arity = 1,
                   description = "The url of target graph to migrate")
        public String targetUrl = "http://127.0.0.1:8081";

        @Parameter(names = {"--target-graph"}, arity = 1,
                   description = "The name of target graph to migrate")
        public String targetGraph = "hugegraph";

        @Parameter(names = {"--target-user"}, arity = 1,
                   description = "The username of target graph to migrate")
        public String targetUsername;

        @Parameter(names = {"--target-password"}, arity = 1,
                   description = "The password of target graph to migrate")
        public String targetPassword;

        @Parameter(names = {"--target-timeout"}, arity = 1,
                   description = "The timeout to connect target graph to " +
                                 "migrate")
        public int targetTimeout;

        @Parameter(names = {"--target-trust-store-file"}, arity = 1,
                   description = "The trust store file of target graph to " +
                                 "migrate")
        public String targetTrustStoreFile;

        @Parameter(names = {"--target-trust-store-password"}, arity = 1,
                   description = "The trust store password of target graph " +
                                 "to migrate")
        public String targetTrustStorePassword;

        @Parameter(names = {"--graph-mode", "-m"}, arity = 1,
                   converter = GraphModeConverter.class,
                   description = "Mode used when migrating to target graph, " +
                                 "include: [RESTORING, MERGING]")
        public GraphMode mode = GraphMode.RESTORING;

        @Parameter(names = {"--keep-local-data"},
                   description = "Whether to keep the local directory of " +
                                 "graph data after restored")
        public boolean keepData = false;

        public long splitSize() {
            return this.splitSize;
        }

        public void splitSize(long splitSize) {
            this.splitSize = splitSize;
        }

        public List<HugeType> types() {
            return this.types.types;
        }

        public void types(List<HugeType> types) {
            this.types.types = types;
        }

        public String targetUrl() {
            return this.targetUrl;
        }

        public String targetGraph() {
            return this.targetGraph;
        }

        public String targetUsername() {
            return this.targetUsername;
        }

        public String targetPassword() {
            return this.targetPassword;
        }

        public int targetTimeout() {
            return this.targetTimeout;
        }

        public String targetTrustStoreFile() {
            return this.targetTrustStoreFile;
        }

        public String targetTrustStorePassword() {
            return this.targetTrustStorePassword;
        }

        public GraphMode mode() {
            return this.mode;
        }

        public boolean keepData() {
            return this.keepData;
        }
    }

    @Parameters(commandDescription = "Create graph with config")
    public static class GraphCreate {

        @Parameter(names = {"--name", "-n"}, arity = 1,
                   description = "The name of new created graph, default is g")
        public String name = "g";

        @ParametersDelegate
        private ConfigFile configFile = new ConfigFile();

        public String name() {
            return this.name;
        }

        public String config() {
            return this.configFile.config;
        }
    }

    @Parameters(commandDescription = "Clone graph")
    public static class GraphClone {

        @Parameter(names = {"--name", "-n"}, arity = 1,
                   description = "The name of new created graph, default is g")
        public String name = "g";

        @Parameter(names = {"--clone-graph-name"}, arity = 1,
                   description = "The name of cloned graph, default is hugegraph")
        public String cloneGraphName = "hugegraph";

        public String name() {
            return this.name;
        }

        public String cloneGraphName() {
            return this.cloneGraphName;
        }
    }

    @Parameters(commandDescription = "List all graphs")
    public static class GraphList {
    }

    @Parameters(commandDescription = "Get graph info")
    public static class GraphGet {}

    @Parameters(commandDescription = "Clear graph schema and data")
    public static class GraphClear {

        @ParametersDelegate
        private ClearConfirmMessage message = new ClearConfirmMessage();

        public String confirmMessage() {
            return this.message.confirmMessage;
        }
    }

    @Parameters(commandDescription = "Drop graph")
    public static class GraphDrop {

        @ParametersDelegate
        private DropConfirmMessage message = new DropConfirmMessage();

        public String confirmMessage() {
            return this.message.confirmMessage;
        }
    }

    @Parameters(commandDescription = "Set graph mode")
    public static class GraphModeSet {

        @ParametersDelegate
        private Mode mode = new Mode();

        public GraphMode mode() {
            return this.mode.mode;
        }
    }

    @Parameters(commandDescription = "Get graph mode")
    public static class GraphModeGet {}

    @Parameters(commandDescription = "Execute Gremlin statements")
    public static class Gremlin extends GremlinJob {

        @ParametersDelegate
        private Aliases aliases = new Aliases();

        public Map<String, String> aliases() {
            return this.aliases.aliases;
        }
    }

    @Parameters(commandDescription = "Execute Gremlin statements as " +
                                     "asynchronous job")
    public static class GremlinJob {

        @ParametersDelegate
        private FileScript fileScript = new FileScript();

        @ParametersDelegate
        private GremlinScript cmdScript = new GremlinScript();

        @ParametersDelegate
        private Language language = new Language();

        @ParametersDelegate
        private Bindings bindings = new Bindings();

        public String fileScript() {
            return this.fileScript.script;
        }

        public String cmdScript() {
            return this.cmdScript.script;
        }

        public String language() {
            return this.language.language;
        }

        public Map<String, String> bindings() {
            return this.bindings.bindings;
        }

        public String script() {
            String script;
            if (this.cmdScript() == null) {
                E.checkArgument(this.fileScript() != null,
                                "Either --script or --file must " +
                                "be provided, but both are null");
                script = this.fileScript();
            } else {
                E.checkArgument(this.fileScript() == null,
                                "Either --script or --file must " +
                                "be provided, but both are provided: " +
                                "'%s' and '%s'",
                                this.cmdScript(), this.fileScript());
                script = this.cmdScript();
            }
            return script;
        }
    }

    @Parameters(commandDescription = "List tasks")
    public static class TaskList {

        @ParametersDelegate
        private TaskStatus status = new TaskStatus();

        @ParametersDelegate
        private Limit limit = new Limit();

        public String status() {
            if (this.status.status == null) {
                return null;
            }
            return this.status.status.toUpperCase();
        }

        public long limit() {
            return this.limit.limit;
        }
    }

    @Parameters(commandDescription = "Get task info")
    public static class TaskGet {

        @ParametersDelegate
        private TaskId taskId = new TaskId();

        public long taskId() {
            return this.taskId.taskId;
        }
    }

    @Parameters(commandDescription = "Delete task")
    public static class TaskDelete {

        @ParametersDelegate
        private TaskId taskId = new TaskId();

        public long taskId() {
            return this.taskId.taskId;
        }
    }

    @Parameters(commandDescription = "Cancel task")
    public static class TaskCancel {

        @ParametersDelegate
        private TaskId taskId = new TaskId();

        public long taskId() {
            return this.taskId.taskId;
        }
    }

    @Parameters(commandDescription = "Clear completed tasks")
    public static class TaskClear {

        @Parameter(names = "--force",
                   description = "Force to clear all tasks, " +
                                 "cancel all uncompleted tasks firstly, " +
                                 "and delete all completed tasks")
        private boolean force = false;

        public boolean force() {
            return this.force;
        }
    }

    @Parameters(commandDescription = "Install HugeGraph-Server and " +
                                     "HugeGraph-Studio")
    public static class Deploy {

        @ParametersDelegate
        private Version version = new Version();

        @ParametersDelegate
        public InstallPath path = new InstallPath();

        @ParametersDelegate
        public DownloadURL url = new DownloadURL();
    }

    @Parameters(commandDescription = "Start HugeGraph-Server and " +
                                     "HugeGraph-Studio")
    public static class StartAll {

        @ParametersDelegate
        private Version version = new Version();

        @ParametersDelegate
        public InstallPath path = new InstallPath();
    }

    @Parameters(commandDescription = "Clear HugeGraph-Server and " +
                                     "HugeGraph-Studio")
    public static class Clear {

        @ParametersDelegate
        public InstallPath path = new InstallPath();
    }

    @Parameters(commandDescription = "Stop HugeGraph-Server and " +
                                     "HugeGraph-Studio")
    public static class StopAll {
    }

    @Parameters(commandDescription = "Print usage")
    public static class Help {
    }

    public static class BackupRestore {

        @Parameter(names = {"--directory", "-d"}, arity = 1,
                   description = "Directory of graph schema/data, default is " +
                                 "'./{graphname}' in local file system " +
                                 "or '{fs.default.name}/{graphname}' in HDFS")
        public String directory;

        @Parameter(names = {"--log", "-l"}, arity = 1,
                   description = "Directory of log")
        public String logDir = "./logs";

        @Parameter(names = {"--thread-num", "-T"}, arity = 1,
                   validateWith = {PositiveValidator.class},
                   description = "Threads number to use, default is " +
                                 "Math.min(10, Math.max(4, CPUs / 2))")
        public int threadsNum;

        @ParametersDelegate
        private Retry retry = new Retry();

        @DynamicParameter(names = "-D",
                          description = "HDFS config parameters")
        private Map<String, String> hdfsConf = new HashMap<>();

        public String directory() {
            return this.directory;
        }

        public String logDir() {
            return this.logDir;
        }

        public int threadsNum() {
            return this.threadsNum;
        }

        public int retry() {
            return this.retry.retry;
        }

        public Map<String, String> hdfsConf() {
            return this.hdfsConf;
        }

        public void directory(String directory) {
            this.directory = directory;
        }

        public void logDir(String logDir) {
            this.logDir = logDir;
        }

        public void retry(int retry) {
            this.retry.retry = retry;
        }

        public void hdfsConf(Map<String, String> hdfsConf) {
            this.hdfsConf = hdfsConf;
        }
    }

    public static class Url {

        @Parameter(names = {"--url"}, arity = 1,
                   validateWith = {UrlValidator.class},
                   description = "The URL of HugeGraph-Server")
        public String url = "http://127.0.0.1:8080";
    }

    public static class Graph {

        @Parameter(names = {"--graph"}, arity = 1,
                   description = "Name of graph")
        public String graph = "hugegraph";
    }

    public static class Username {

        @Parameter(names = {"--user"}, arity = 1,
                   description = "Name of user")
        public String username;
    }

    public static class Password {

        @Parameter(names = {"--password"}, arity = 1,
                   description = "Password of user")
        public String password;
    }

    public static class Timeout {

        @Parameter(names = {"--timeout"}, arity = 1,
                   description = "Connection timeout")
        public int timeout = 30;
    }

    public static class Protocol {

        @Parameter(names = {"--protocol"}, arity = 1,
                   validateWith = {ProtocolValidator.class},
                   description = "The Protocol of HugeGraph-Server, allowed values " +
                                 "are: http or https")
        public String protocol = "http";
    }

    public static class TrustStoreFile {

        @Parameter(names = {"--trust-store-file"}, arity = 1,
                   description = "The path of client truststore file used when " +
                                 "https protocol is enabled")
        public String trustStoreFile;
    }

    public static class TrustStorePassword {

        @Parameter(names = {"--trust-store-password"}, arity = 1,
                   description = "The password of the client truststore file " +
                                 "used when the https protocol is enabled")
        public String trustStorePassword;
    }

    public static class ThrowMode {

        @Parameter(names = {"--throw-mode"}, arity = 1,
                   description = "Whether the hugegraph-tools work " +
                                 "to throw an exception")
        public boolean throwMode = false;
    }

    public static class HugeTypes {

        @Parameter(names = {"--huge-types", "-t"},
                   listConverter = HugeTypeListConverter.class,
                   description = "Type of schema/data. Concat with ',' if more " +
                                 "than one. Other types include 'all' and " +
                                 "'schema'. 'all' means all vertices, edges and " +
                                 "schema. In other words, 'all' equals with " +
                                 "'vertex, edge, vertex_label, edge_label, " +
                                 "property_key, index_label'. 'schema' equals " +
                                 "with 'vertex_label, edge_label, property_key, " +
                                 "index_label'.")
        public List<HugeType> types = HugeTypeListConverter.ALL_TYPES;
    }

    public static class InstallPath {

        @Parameter(names = {"-p"}, arity = 1, required = true,
                   description = "Install path of HugeGraph-Server and " +
                                 "HugeGraph-Studio")
        public String directory;
    }

    public static class DownloadURL {

        @Parameter(names = {"-u"}, arity = 1,
                   description = "Download url prefix path of " +
                                 "HugeGraph-Server and HugeGraph-Studio")
        public String url = null;
    }

    public static class ClearConfirmMessage {

        @Parameter(names = {"--confirm-message", "-c"}, arity = 1,
                   description = "Confirm message of graph clear is " +
                                 "\"I'm sure to delete all data\". " +
                                 "(Note: include \"\")",
                   required = true)
        public String confirmMessage;
    }

    public static class DropConfirmMessage {

        @Parameter(names = {"--confirm-message", "-c"}, arity = 1,
                   description = "Confirm message of graph clear is " +
                                 "\"I'm sure to drop the graph\". " +
                                 "(Note: include \"\")",
                   required = true)
        public String confirmMessage;
    }

    public static class Mode {

        @Parameter(names = {"--graph-mode", "-m"}, arity = 1,
                   converter = GraphModeConverter.class,
                   description = "Graph mode, " +
                                 "include: [NONE, RESTORING, MERGING]",
                   required = true)
        public GraphMode mode;
    }

    public static class FileScript {

        @Parameter(names = {"--file", "-f"}, arity = 1,
                   converter = FileNameToContentConverter.class,
                   description = "Gremlin Script file to be executed, UTF-8 " +
                                 "encoded, exclusive to --script")
        public String script;
    }

    public static class ConfigFile {

        @Parameter(names = {"--file", "-f"}, arity = 1,
                   converter = FileNameToContentConverter.class,
                   description = "Creating graph config file")
        public String config;
    }

    public static class GremlinScript {

        @Parameter(names = {"--script", "-s"}, arity = 1,
                   description = "Gremlin script to be executed, " +
                                 "exclusive to --file")
        public String script;
    }

    public static class Language {

        @Parameter(names = {"--language", "-l"}, arity = 1,
                   description = "Gremlin script language")
        public String language = "gremlin-groovy";
    }

    public static class Bindings {

        @Parameter(names = {"--bindings", "-b"}, arity = 1,
                   converter = MapConverter.class,
                   description = "Gremlin bindings, valid format is: " +
                                 "'key1=value1,key2=value2...'")
        public Map<String, String> bindings = ImmutableMap.of();
    }

    public static class Aliases {

        @Parameter(names = {"--aliases", "-a"}, arity = 1,
                   converter = MapConverter.class,
                   description = "Gremlin aliases, valid format is: " +
                                 "'key1=value1,key2=value2...'")
        public Map<String, String> aliases = ImmutableMap.of();
    }

    public static class Version {

        @Parameter(names = {"-v"}, arity = 1, required = true,
                   description = "Version of HugeGraph-Server and " +
                                 "HugeGraph-Studio")
        public String version;
    }

    public static class Retry {

        @Parameter(names = {"--retry"}, arity = 1,
                   validateWith = {PositiveValidator.class},
                   description = "Retry times, default is 3")
        public int retry = 3;
    }

    public static class Limit {

        @Parameter(names = {"--limit"}, arity = 1,
                   validateWith = {PositiveValidator.class},
                   description = "Limit number, no limit if not provided")
        public long limit = -1;
    }

    public static class TaskStatus {

        @Parameter(names = {"--status"}, arity = 1,
                   validateWith = TaskStatusValidator.class,
                   description = "Status of task")
        public String status = null;
    }

    public static class TaskId {

        @Parameter(names = {"--task-id"}, arity = 1, required = true,
                   validateWith = {PositiveValidator.class},
                   description = "Task id")
        private long taskId;
    }

    public static class AuthBackupRestore {

        @ParametersDelegate
        private AuthTypes types = new AuthTypes();

        @Parameter(names = {"--directory"}, arity = 1,
                   description = "Directory of auth information, default " +
                                 "is './{auth-backup-restore}' in local " +
                                 "file system or '{fs.default.name}/" +
                                 "{auth-backup-restore}' in HDFS")
        public String directory;

        @DynamicParameter(names = "-D",
                          description = "HDFS config parameters")
        private Map<String, String> hdfsConf = new HashMap<>();

        @ParametersDelegate
        private Retry retry = new Retry();

        public List<HugeType> types() {
            return this.types.types;
        }

        public void types(List<HugeType> types) {
            this.types.types = types;
        }

        public int retry() {
            return this.retry.retry;
        }

        public void retry(int retry) {
            this.retry.retry = retry;
        }

        public String directory() {
            return this.directory;
        }

        public void directory(String directory) {
            this.directory = directory;
        }

        public Map<String, String> hdfsConf() {
            return this.hdfsConf;
        }

        public void hdfsConf(Map<String, String> hdfsConf) {
            this.hdfsConf = hdfsConf;
        }
    }

    public static class AuthBackup extends AuthBackupRestore {
    }

    public static class AuthRestore extends AuthBackupRestore {

        @Parameter(names = {"--strategy"},
                   converter = AuthStrategyConverter.class,
                   description = "The strategy needs to be chosen in the event " +
                                 "of a conflict when restoring. Valid " +
                                 "strategies include 'stop' and 'ignore', " +
                                 "default is 'stop'. 'stop' means if there " +
                                 "a conflict, stop restore. 'ignore' means if " +
                                 "there a conflict, ignore and continue to " +
                                 "restore.")
        public AuthRestoreConflictStrategy strategy = AuthStrategyConverter.strategy;

        @Parameter(names = {"--init-password"}, arity = 1,
                   description = "Init user password, if restore type include " +
                                 "'user', please specify the init-password of " +
                                 "users.")
        public String initPassword = StringUtils.EMPTY;

        public AuthRestoreConflictStrategy strategy() {
            return this.strategy;
        }

        public void strategy(AuthRestoreConflictStrategy strategy) {
            this.strategy = strategy;
        }

        public String initPassword() {
            return this.initPassword;
        }

        public void initPassword(String initPassword) {
            this.initPassword = initPassword;
        }
    }

    public static class AuthTypes {

        @Parameter(names = {"--types", "-t"},
                   listConverter = AuthHugeTypeConverter.class,
                   description = "Type of auth data to restore and backup, " +
                                 "concat with ',' if more than one. 'all' " +
                                 "means all auth information. In other words, " +
                                 "'all' equals with 'user, group, target, " +
                                 "belong, access'. In addition, 'belong' or " +
                                 "'access' can not backup or restore alone, if " +
                                 "type contains 'belong' then should contains " +
                                 "'user' and 'group'. If type contains 'access' " +
                                 "then should contains 'group' and 'target'.")
        public List<HugeType> types = AuthHugeTypeConverter.AUTH_ALL_TYPES;
    }

    public static class GraphModeConverter
                  implements IStringConverter<GraphMode> {

        @Override
        public GraphMode convert(String value) {
            E.checkArgument(value != null && !value.isEmpty(),
                            "GraphMode can't be null or empty");
            return GraphMode.valueOf(value);
        }
    }

    public static class HugeTypeListConverter
                  implements IStringConverter<List<HugeType>> {

        public static final List<HugeType> ALL_TYPES = ImmutableList.of(
                HugeType.PROPERTY_KEY, HugeType.VERTEX_LABEL,
                HugeType.EDGE_LABEL, HugeType.INDEX_LABEL,
                HugeType.VERTEX, HugeType.EDGE
        );

        public static final List<HugeType> SCHEMA_TYPES = ImmutableList.of(
                HugeType.PROPERTY_KEY, HugeType.VERTEX_LABEL,
                HugeType.EDGE_LABEL, HugeType.INDEX_LABEL
        );

        @Override
        public List<HugeType> convert(String value) {
            E.checkArgument(value != null && !value.isEmpty(),
                            "HugeType can't be null or empty");
            String[] types = value.split(",");
            if (types.length == 1 && types[0].equalsIgnoreCase("all")) {
                return ALL_TYPES;
            }
            if (types.length == 1 && types[0].equalsIgnoreCase("schema")) {
                return SCHEMA_TYPES;
            }
            List<HugeType> hugeTypes = new ArrayList<>();
            for (String type : types) {
                try {
                    hugeTypes.add(HugeType.valueOf(type.toUpperCase()));
                } catch (IllegalArgumentException e) {
                    throw new ParameterException(String.format(
                              "Invalid --type '%s', valid value is 'all' or " +
                              "combination of 'vertex,edge,vertex_label," +
                              "edge_label,property_key,index_label'", type));
                }
            }
            return hugeTypes;
        }
    }

    public static class AuthHugeTypeConverter
                  implements IStringConverter<List<HugeType>> {

        public static final List<HugeType> AUTH_ALL_TYPES = ImmutableList.of(
                HugeType.TARGET, HugeType.GROUP,
                HugeType.USER, HugeType.ACCESS,
                HugeType.BELONG
        );

        @Override
        public List<HugeType> convert(String value) {
            E.checkArgument(value != null && !value.isEmpty(),
                            "HugeType can't be null or empty");
            String[] types = value.split(",");
            if (types.length == 1 && types[0].equalsIgnoreCase("all")) {
                return AUTH_ALL_TYPES;
            }
            List<String> typeList = Arrays.asList(types);
            E.checkArgument(!typeList.contains(HugeType.BELONG.toString().toLowerCase()) ||
                            (typeList.contains(HugeType.USER.toString().toLowerCase()) &&
                            typeList.contains(HugeType.GROUP.toString().toLowerCase())),
                            "Invalid --type '%s', if type contains 'belong'" +
                            " then 'user' and 'group' are required.", value);
            E.checkArgument(!typeList.contains(HugeType.ACCESS.toString().toLowerCase()) ||
                            (typeList.contains(HugeType.GROUP.toString().toLowerCase()) &&
                            typeList.contains(HugeType.TARGET.toString().toLowerCase())),
                            "Invalid --type '%s', if type contains 'access'" +
                            " then 'group' and 'target' are required.", value);
            List<HugeType> hugeTypes = new ArrayList<>();
            for (String type : types) {
                try {
                    hugeTypes.add(HugeType.valueOf(type.toUpperCase()));
                } catch (IllegalArgumentException e) {
                    throw new IllegalArgumentException(String.format(
                              "Invalid --type '%s', valid value is 'all' or " +
                              "combination of [user,group,target," +
                              "belong,access]", type));
                }
            }
            return hugeTypes;
        }
    }

    public static class AuthStrategyConverter
                  implements IStringConverter<AuthRestoreConflictStrategy> {

        public static final AuthRestoreConflictStrategy strategy =
                            AuthRestoreConflictStrategy.STOP;

        @Override
        public AuthRestoreConflictStrategy convert(String value) {
            E.checkArgument(value != null && !value.isEmpty(),
                            "Strategy can't be null or empty");
            E.checkArgument(AuthRestoreConflictStrategy.matchStrategy(value),
                            "Invalid --strategy '%s', valid value is " +
                            "'stop' or 'ignore", value);
            return AuthRestoreConflictStrategy.fromName(value);
        }
    }

    public static class MapConverter
                  implements IStringConverter<Map<String, String>> {

        @Override
        public Map<String, String> convert(String value) {
            E.checkArgument(value != null && !value.isEmpty(),
                            "HugeType can't be null or empty");
            String[] equals = value.split(",");
            Map<String, String> result = new HashMap<>();
            for (String equal : equals) {
                String[] kv = equal.split("=");
                E.checkArgument(kv.length == 2,
                                "Map arguments format should be key=value, " +
                                "but got '%s'", equal);
                result.put(kv[0], kv[1]);
            }
            return result;
        }
    }

    public static class FileNameToContentConverter
                  implements IStringConverter<String> {

        @Override
        public String convert(String value) {
            File file = FileUtils.getFile(value);
            if (!file.exists() || !file.isFile() || !file.canRead()) {
                throw new ParameterException(String.format(
                          "'%s' must be existed readable file", value));
            }
            String content;
            try {
                content = FileUtils.readFileToString(file, API.CHARSET);
            } catch (IOException e) {
                throw new ParameterException(String.format(
                          "Read file '%s' error", value), e);
            }
            return content;
        }
    }

    public static class FormatValidator implements IParameterValidator {

        private static final Set<String> FORMATS = ImmutableSet.of(
                "JSON", "TEXT"
        );

        @Override
        public void validate(String name, String value) {
            if (!FORMATS.contains(value.toUpperCase())) {
                throw new ParameterException(String.format(
                          "Invalid --format '%s', valid value is %s",
                          value, FORMATS));
            }
        }
    }

    public static class ProtocolValidator implements IParameterValidator {

        private static final Set<String> PROTOCOLS = ImmutableSet.of(
                "HTTP", "HTTPS"
        );

        @Override
        public void validate(String name, String value) {
            if (!PROTOCOLS.contains(value.toUpperCase())) {
                throw new ParameterException(String.format(
                          "Invalid --protocol '%s', valid value is %s",
                          value, PROTOCOLS));
            }
        }
    }

    public static class TaskStatusValidator implements IParameterValidator {

        @Override
        public void validate(String name, String value) {
            if (!TasksManager.TASK_STATUSES.contains(value.toUpperCase())) {
                throw new ParameterException(String.format(
                          "Invalid --status '%s', valid value is %s",
                          value, TasksManager.TASK_STATUSES));
            }
        }
    }

    public static class UrlValidator implements IParameterValidator {

        @Override
        public void validate(String name, String value) {
            String regex = "^((http)(s?)://)?"
                    // IP URL, like: 10.0.0.1
                    + "(((25[0-5])|(2[0-4]\\d)|(1\\d\\d)|([1-9]\\d)|\\d)"
                    + "(\\.((25[0-5])|(2[0-4]\\d)|(1\\d\\d)|([1-9]\\d)|\\d)){3}"
                    + "|"
                    // Or domain name
                    + "([0-9a-z_!~*'()-]+\\.)*[0-9a-z_!~*'()-]+)"
                    // Port
                    + ":([0-9]|[1-9]\\d{1,3}|[1-5]\\d{4}|6[0-5]{2}[0-3][0-5])$";
            if (!value.matches(regex)) {
                throw new ParameterException(String.format(
                          "Invalid url value of args '%s': '%s'", name, value));
            }
        }
    }

    public static class DirectoryValidator implements IParameterValidator {

        @Override
        public void validate(String name, String value) {
            File file = new File(value);
            if (!file.exists() || !file.isDirectory()) {
                throw new ParameterException(String.format(
                          "Invalid value of argument '%s': '%s'", name, value));
            }
        }
    }

    public static class PositiveValidator implements IParameterValidator {

        @Override
        public void validate(String name, String value) {
            int retry = Integer.parseInt(value);
            if (retry <= 0) {
                throw new ParameterException(
                          "Parameter " + name + " should be positive, " +
                          "but got " + value);
            }
        }
    }
}