package net.filebot.cli;

import static java.awt.GraphicsEnvironment.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static java.util.stream.Collectors.*;
import static net.filebot.hash.VerificationUtilities.*;
import static net.filebot.media.XattrMetaInfo.*;
import static net.filebot.subtitle.SubtitleUtilities.*;
import static net.filebot.util.FileUtilities.*;

import java.io.File;
import java.io.FileFilter;
import java.io.StringWriter;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.logging.Level;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.kohsuke.args4j.Argument;
import org.kohsuke.args4j.CmdLineException;
import org.kohsuke.args4j.CmdLineParser;
import org.kohsuke.args4j.Option;
import org.kohsuke.args4j.ParserProperties;
import org.kohsuke.args4j.spi.StopOptionHandler;

import net.filebot.ApplicationFolder;
import net.filebot.GroovyEngine;
import net.filebot.Language;
import net.filebot.RenameAction;
import net.filebot.StandardPostProcessAction;
import net.filebot.StandardRenameAction;
import net.filebot.WebServices;
import net.filebot.format.ExpressionFileComparator;
import net.filebot.format.ExpressionFileFilter;
import net.filebot.format.ExpressionFileFormat;
import net.filebot.format.ExpressionFilter;
import net.filebot.format.ExpressionFormat;
import net.filebot.format.ExpressionMapper;
import net.filebot.format.QueryExpression;
import net.filebot.hash.HashType;
import net.filebot.postprocess.Apply;
import net.filebot.postprocess.Script;
import net.filebot.subtitle.SubtitleFormat;
import net.filebot.subtitle.SubtitleNaming;
import net.filebot.ui.Mode;
import net.filebot.web.Datasource;
import net.filebot.web.SortOrder;

public class ArgumentBean {

        @Option(name = "-rename", usage = "Rename media files")
        public boolean rename = false;

        @Option(name = "--db", usage = "Database", metaVar = "[TheTVDB, AniDB, TheMovieDB::TV] or [TheMovieDB] or [AcoustID, ID3] or [xattr, exif, file]")
        public String db;

        @Option(name = "--order", usage = "Episode order", metaVar = "[Airdate, DVD, Absolute, Digital, Production, Date]")
        public String order = "Airdate";

        @Option(name = "--format", usage = "Format expression", handler = GroovyExpressionHandler.class)
        public String format;

        @Option(name = "--action", usage = "Rename action", metaVar = "[move, copy, keeplink, symlink, hardlink, clone, test]")
        public String action = "move";

        @Option(name = "--conflict", usage = "Conflict resolution", metaVar = "[skip, replace, auto, index, fail]")
        public String conflict = "skip";

        @Option(name = "--filter", usage = "Filter expression", handler = GroovyExpressionHandler.class)
        public String filter = null;

        @Option(name = "--mapper", usage = "Mapper expression", handler = GroovyExpressionHandler.class)
        public String mapper = null;

        @Option(name = "--q", usage = "Query expression", metaVar = "[name] or [id] or {expression}", handler = GroovyExpressionHandler.class)
        public String query;

        @Option(name = "--lang", usage = "Language", metaVar = "[English, German, ...]")
        public String lang = "en";

        @Option(name = "-non-strict", usage = "Enable advanced matching and more aggressive guess work")
        public boolean nonStrict = false;

        @Option(name = "-r", usage = "Select files from folders recursively")
        public boolean recursive = false;

        @Option(name = "-d", usage = "Select folders")
        public boolean directory = false;

        @Option(name = "--file-filter", usage = "Input file filter expression", handler = GroovyExpressionHandler.class)
        public String inputFileFilter = null;

        @Option(name = "--file-order", usage = "Input file order expression", handler = GroovyExpressionHandler.class)
        public String inputFileOrder = null;

        @Option(name = "--output", usage = "Output directory", metaVar = "/path/to/folder")
        public String output;

        @Option(name = "--apply", usage = "Apply post-processing actions", metaVar = "[artwork, cover, nfo, metadata, import, srt, date, tags, chmod, touch, prune, clean]", handler = ApplyOptionsHandler.class)
        public List<String> apply = new ArrayList<String>();

        @Option(name = "-exec", usage = "Execute command", metaVar = "echo {f} [+*]", handler = ExecOptionsHandler.class)
        public List<String> exec = new ArrayList<String>();

        @Option(name = "-extract", usage = "Extract archives")
        public boolean extract = false;

        @Option(name = "-check", usage = "Create / Check verification files")
        public boolean check;

        @Option(name = "-get-subtitles", usage = "Fetch subtitles")
        public boolean getSubtitles;

        @Option(name = "--encoding", usage = "Output character encoding", metaVar = "[UTF-8, Windows-1252]")
        public String encoding;

        @Option(name = "-list", usage = "Print episode list")
        public boolean list = false;

        @Option(name = "-find", usage = "Print file paths")
        public boolean find = false;

        @Option(name = "-mediainfo", usage = "Print media info")
        public boolean mediaInfo = false;

        @Option(name = "-script", usage = "Run Groovy script", metaVar = "[fn:name] or [script.groovy]")
        public String script = null;

        @Option(name = "--def", usage = "Define script variables", handler = BindingsHandler.class)
        public Map<String, String> defines = new LinkedHashMap<String, String>();

        @Option(name = "-revert", usage = "Revert files")
        public boolean revert = false;

        @Option(name = "--mode", usage = "Enable CLI interactive mode", metaVar = "[interactive]")
        public String mode = null;

        @Option(name = "--log", usage = "Log level", metaVar = "[all, fine, info, warning, off]")
        public String log;

        @Option(name = "--log-file", usage = "Log file", metaVar = "*.txt")
        public String logFile = null;

        @Option(name = "-clear-cache", usage = "Clear cached and temporary data")
        public boolean clearCache = false;

        @Option(name = "-clear-prefs", usage = "Clear application settings")
        public boolean clearPrefs = false;

        @Option(name = "-clear-history", usage = "Clear rename history")
        public boolean clearHistory = false;

        @Option(name = "-unixfs", usage = "Allow special characters in file paths")
        public boolean unixfs = false;

        @Option(name = "-no-xattr", usage = "Disable extended attributes")
        public boolean disableExtendedAttributes = false;

        @Option(name = "-no-probe", usage = "Disable media parser")
        public boolean disableMediaParser = false;

        @Option(name = "-no-history", usage = "Disable history")
        public boolean disableHistory = false;

        @Option(name = "-no-index", usage = "Disable media index")
        public boolean disableMediaIndex = false;

        @Option(name = "-version", usage = "Print version identifier")
        public boolean version = false;

        @Option(name = "-help", usage = "Print this help message")
        public boolean help = false;

        @Option(name = "--license", usage = "Import license file", handler = LicenseOptionHandler.class)
        public String license = null;

        @Argument
        @Option(name = "--", handler = StopOptionHandler.class)
        public List<String> arguments = new ArrayList<String>();

        public boolean runCLI() {
                return rename || getSubtitles || check || list || find || mediaInfo || revert || extract || script != null || (license != null && (System.console() != null || isHeadless()));
        }

        public boolean isInteractive() {
                return "interactive".equalsIgnoreCase(mode);
        }

        public boolean printVersion() {
                return version;
        }

        public boolean printHelp() {
                return help;
        }

        public boolean clearCache() {
                return clearCache;
        }

        public boolean clearUserData() {
                return clearPrefs;
        }

        public boolean clearHistory() {
                return clearHistory;
        }

        public List<File> getFileArguments() throws Exception {
                if (arguments.isEmpty()) {
                        return emptyList();
                }

                if (recursive || inputFileFilter != null || inputFileOrder != null) {
                        return getFiles();
                }

                // resolve relative paths
                return getInputArguments();
        }

        public List<File> getFiles() throws Exception {
                List<File> selection = getInputArguments();

                // use the current working directory as input folder if no input arguments were given
                if (selection.isEmpty() && arguments.isEmpty() && find) {
                        File workingDirectory = new File(".").getCanonicalFile();
                        selection = asList(workingDirectory);
                }

                // resolve given paths
                List<File> files = new ArrayList<File>();

                // resolve relative paths
                for (File file : selection) {
                        if (file.isDirectory()) {
                                if (directory) {
                                        if (find || recursive) {
                                                files.addAll(listFiles(file, FOLDERS, HUMAN_NAME_ORDER));
                                        } else {
                                                files.add(file);
                                        }
                                } else if (find || recursive) {
                                        files.addAll(listFiles(file, FILES, HUMAN_NAME_ORDER));
                                } else {
                                        files.addAll(getChildren(file, f -> f.isFile() && !f.isHidden(), HUMAN_NAME_ORDER));
                                }
                        } else {
                                files.add(file);
                        }
                }

                // input file filter (e.g. useful on Windows where find -exec is not an option)
                if (inputFileFilter != null && !files.isEmpty()) {
                        files = filter(files, new ExpressionFileFilter(inputFileFilter));
                }

                if (inputFileOrder != null && !files.isEmpty()) {
                        files.sort(ExpressionFileComparator.parse(inputFileOrder));
                }

                return files;
        }

        public List<File> getInputArguments() {
                return arguments.stream().map(File::new).map(f -> {
                        try {
                                return getRealPath(f);
                        } catch (Exception e) {
                                return f.getAbsoluteFile();
                        }
                }).collect(toList());
        }

        public RenameAction getRenameAction() {
                // support custom executables (via absolute path)
                if (action.startsWith("/")) {
                        return ExecutableRenameAction.executable(new File(action), getOutputPath());
                }

                // support custom groovy scripts (via files or closures)
                if (isGroovyScript(action)) {
                        return resolveGroovyScript(action, GroovyAction::new, "Invalid --action script");
                }

                return optional(action, StandardRenameAction::forName, "Invalid --action value").orElse(StandardRenameAction.MOVE);
        }

        public ConflictAction getConflictAction() {
                // support custom groovy scripts (via files or closures)
                if (isGroovyScript(conflict)) {
                        return resolveGroovyScript(conflict, GroovyAction::new, "Invalid --conflict script");
                }

                return optional(conflict, StandardConflictAction::forName, "Invalid --conflict value").orElse(StandardConflictAction.SKIP);
        }

        public SortOrder getSortOrder() {
                return optional(order, SortOrder::forName, "Invalid --order value").orElse(SortOrder.Airdate);
        }

        public ExpressionFormat getExpressionFormat() throws Exception {
                return format == null ? null : new ExpressionFormat(format);
        }

        public ExpressionFileFormat getExpressionFileFormat() throws Exception {
                return format == null ? null : new ExpressionFileFormat(format);
        }

        public ExpressionFilter getExpressionFilter() throws Exception {
                return filter == null ? null : new ExpressionFilter(filter);
        }

        public FileFilter getExpressionFileFilter() throws Exception {
                return filter == null ? null : new ExpressionFileFilter(filter, xattr::getMetaInfo);
        }

        public ExpressionMapper getExpressionMapper() throws Exception {
                return mapper == null ? null : new ExpressionMapper(mapper);
        }

        public Datasource getDatasource() {
                return optional(db, WebServices::getService, "Invalid --db value").orElse(null);
        }

        public QueryExpression getQueryExpression() throws Exception {
                return query == null ? null : new QueryExpression(query);
        }

        public File getOutputPath() {
                return output == null ? null : new File(output);
        }

        public File getAbsoluteOutputFolder() {
                return optional(output, s -> prepareOutputPath(s, null), "Invalid --output folder path").orElse(null);
        }

        public SubtitleFormat getSubtitleOutputFormat() {
                return output == null ? null : getSubtitleFormatByName(output);
        }

        public SubtitleNaming getSubtitleNamingFormat() {
                return optional(format, SubtitleNaming::forName, "Invalid subtitle naming --format value").orElse(SubtitleNaming.MATCH_VIDEO_ADD_LANGUAGE_TAG);
        }

        public HashType getOutputHashType() {
                // support --format SFV
                return optional(format, s -> getHashType(s), "Invalid checksum --format value").orElseGet(() -> {
                        // support --output checksum.sfv
                        return optional(output, s -> getHashType(new File(s)), "Invalid checksum --output path").orElse(HashType.SFV);
                });
        }

        public Charset getEncoding() {
                return optional(encoding, Charset::forName, "Invalid --encoding value").orElse(null);
        }

        public Language getLanguage() {
                // find language code for any input (en, eng, English, etc)
                return optional(lang, Language::forName, "Invalid --lang value").orElseGet(Language::defaultLanguage);
        }

        public File getLogFile() {
                // resolve relative paths against {application.dir}/logs
                return optional(logFile, s -> prepareOutputPath(s, ApplicationFolder.Logs.getDirectory()), "Invalid --log-file path").orElse(null);
        }

        public boolean isStrict() {
                return !nonStrict;
        }

        public Level getLogLevel() {
                return optional(log, s -> Level.parse(s.toUpperCase()), "Invalid --log level").orElse(Level.ALL);
        }

        public ExecCommand getExecCommand() {
                return exec.isEmpty() ? null : optional(exec, arguments -> ExecCommand.parse(arguments, getOutputPath()), "Invalid --exec expression").orElse(null);
        }

        public Apply[] getPostProcessActions() {
                return apply.isEmpty() ? null : optional(apply, arguments -> {
                        return arguments.stream().map(v -> {
                                if (isGroovyScript(v)) {
                                        return resolveGroovyScript(v, Script::new, "Invalid --apply post-processing script");
                                }
                                return StandardPostProcessAction.forName(v);
                        }).toArray(Apply[]::new);
                }, "Invalid --apply post-processing action").orElse(null);
        }

        public Mode[] getPanelMode() {
                return optional(mode, s -> new Mode[] { Mode.forName(mode) }, "Invalid --mode value").orElseGet(Mode::modes);
        }

        public String getLicenseKey() {
                return license;
        }

        private final String[] args;

        public ArgumentBean() {
                this.args = new String[0];
        }

        public ArgumentBean(String[] args, boolean expand) throws CmdLineException {
                // can't use built-in @file syntax because args4j doesn't use UTF-8 on Windows and fails to ignore BOM markers
                CmdLineParser parser = new CmdLineParser(this, ParserProperties.defaults().withAtSyntax(false));
                try {
                        this.args = expand ? expandAtFiles(args) : args.clone();
                } catch (Exception e) {
                        throw new CmdLineException(parser, e.getMessage(), e);
                }
                // NOTE: CmdLineParser::parseArgument may modify the String[] input parameter
                parser.parseArgument(this.args.clone());
        }

        public String[] getArgumentArray() {
                return args.clone();
        }

        public String usage() {
                StringWriter buffer = new StringWriter(4096);
                CmdLineParser parser = new CmdLineParser(this, ParserProperties.defaults().withShowDefaults(false).withOptionSorter(null));
                parser.printUsage(buffer, null);
                return buffer.toString();
        }

        @Override
        public String toString() {
                return toString(args);
        }

        private File prepareOutputPath(String path, File directory) {
                try {
                        File file = new File(path);
                        // resolve relative path is necessary
                        if (directory != null && !file.isAbsolute()) {
                                file = new File(directory, path);
                        }
                        // get canonical absolute path
                        return file.getCanonicalFile();
                } catch (Exception e) {
                        throw new IllegalArgumentException(e.getMessage());
                }
        }

        private static boolean isGroovyScript(String value) {
                return value.startsWith("{") || value.endsWith("}") || value.endsWith(".groovy");
        }

        private static <T> T resolveGroovyScript(String value, BiFunction<String, String, T> mapper, String error) {
                try {
                        // as external source file
                        if (GroovyEngine.isGroovyFile(value)) {
                                File source = new File(value).getAbsoluteFile();
                                return mapper.apply(source.getName(), GroovyEngine.resolveExternalScript(source));
                        }
                        // as code
                        return mapper.apply("GROOVY", GroovyEngine.resolveScript(value));
                } catch (Exception e) {
                        // return helpful error messages
                        throw new CmdlineException(error + ": " + quote(value) + ": " + e.getMessage());
                }
        }

        private static <S, T> Optional<T> optional(S value, Function<S, T> mapper, String error) {
                try {
                        return Optional.ofNullable(value).map(mapper);
                } catch (CmdlineException e) {
                        // pass through helpful error messages
                        throw e;
                } catch (Exception e) {
                        // return helpful error messages
                        throw new CmdlineException(error + ": " + quote(value) + ": " + e.getMessage());
                }
        }

        private static String quote(Object value) {
                return value instanceof List ? value.toString() : "'" + value + "'";
        }

        public static String toString(String[] args) {
                return IntStream.range(0, args.length).mapToObj(i -> {
                        return String.format("args[%s] = %s", i + 1, args[i]);
                }).collect(joining(System.lineSeparator()));
        }

        public static String[] expandAtFiles(String[] args) {
                return stream(args).flatMap(a -> {
                        if (a.startsWith("@")) {
                                File f = new File(a.substring(1)).getAbsoluteFile();
                                if (f.exists()) {
                                        try {
                                                return readLines(f).stream().map(line -> {
                                                        // fix superfluous quotes
                                                        if (line.startsWith("\"") && line.endsWith("\"")) {
                                                                return line.substring(1, line.length() - 1);
                                                        }
                                                        // fix superfluous spaces
                                                        return line.trim();
                                                });
                                        } catch (Exception e) {
                                                throw new CmdlineException("Invalid @file path", f, e);
                                        }
                                }
                        }
                        return Stream.of(a);
                }).toArray(String[]::new);
        }

        public static ArgumentBean parse(String... args) throws CmdLineException {
                try {
                        return new ArgumentBean(args, true);
                } catch (CmdLineException e) {
                        // MAS does not support or allow command-line applications and may run executables with strange arguments for no apparent reason (e.g. filebot.launcher -psn_0_774333) so we ignore arguments completely in this case
                        if (Boolean.parseBoolean(System.getProperty("apple.app.launcher"))) {
                                return new ArgumentBean();
                        }
                        // just throw exception as usual when called from command-line and display argument errors
                        throw e;
                }
        }

}