/*
 * Copyright (c) 2018, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
 *
 * 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 org.ballerinalang.openapi;

import com.github.jknack.handlebars.Context;
import com.github.jknack.handlebars.Handlebars;
import com.github.jknack.handlebars.Template;
import com.github.jknack.handlebars.context.FieldValueResolver;
import com.github.jknack.handlebars.context.JavaBeanValueResolver;
import com.github.jknack.handlebars.context.MapValueResolver;
import com.github.jknack.handlebars.helper.StringHelpers;
import com.github.jknack.handlebars.io.ClassPathTemplateLoader;
import com.github.jknack.handlebars.io.FileTemplateLoader;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.parser.OpenAPIV3Parser;
import org.apache.commons.lang3.StringUtils;
import org.ballerinalang.openapi.exception.BallerinaOpenApiException;
import org.ballerinalang.openapi.model.BallerinaOpenApi;
import org.ballerinalang.openapi.model.GenSrcFile;
import org.ballerinalang.openapi.typemodel.BallerinaOpenApiType;
import org.ballerinalang.openapi.utils.CodegenUtils;
import org.ballerinalang.openapi.utils.GeneratorConstants;
import org.ballerinalang.openapi.utils.GeneratorConstants.GenType;
import org.ballerinalang.openapi.utils.TypeExtractorUtil;
import org.ballerinalang.tool.LauncherUtils;
import org.wso2.ballerinalang.compiler.util.ProjectDirs;

import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import static org.ballerinalang.openapi.model.GenSrcFile.GenFileType;
import static org.ballerinalang.openapi.utils.GeneratorConstants.GenType.GEN_CLIENT;
import static org.ballerinalang.openapi.utils.GeneratorConstants.MODULE_MD;

/**
 * This class generates Ballerina Services/Clients for a provided OAS definition.
 */
public class CodeGenerator {
    private String srcPackage;
    private String modelPackage;

    private static final PrintStream outStream = System.err;

    /**
     * Generates ballerina source for provided Open API Definition in {@code definitionPath}.
     * Generated source will be written to a ballerina module at {@code outPath}
     * <p>Method can be user for generating Ballerina mock services and clients</p>
     *
     * @param type           Output type. Following types are supported
     *                       <ul>
     *                       <li>mock</li>
     *                       <li>client</li>
     *                       </ul>
     * @param executionPath  Command execution path
     * @param definitionPath Input Open Api Definition file path
     * @param serviceName    Output Service Name
     * @param outPath        Destination file path to save generated source files. If not provided
     *                       {@code definitionPath} will be used as the default destination path
     * @throws IOException               when file operations fail
     * @throws BallerinaOpenApiException when code generator fails
     */
    private void generate(GenType type, String executionPath, String definitionPath,
                          String reldefinitionPath , String serviceName, String outPath)
            throws IOException, BallerinaOpenApiException {

        if (!CodegenUtils.isBallerinaProject(Paths.get(outPath))) {
            throw new BallerinaOpenApiException(OpenApiMesseges.GEN_CLIENT_PROJECT_ROOT);
        }

        //Check if the selected path is a ballerina root for service generation
        //TODO check with team for root check
        Path projectRoot = ProjectDirs.findProjectRoot(Paths.get(executionPath));
        if (type.equals(GenType.GEN_SERVICE) && projectRoot == null) {
            throw LauncherUtils.createUsageExceptionWithHelp(OpenApiMesseges.GEN_SERVICE_PROJECT_ROOT);
        }

        Path srcPath = CodegenUtils.getSourcePath(srcPackage, outPath);
        Path implPath = CodegenUtils.getImplPath(srcPackage, srcPath);

        if (type.equals(GEN_CLIENT)) {
            if (srcPackage.equals("")) {
                srcPath = srcPath.resolve("client");
                implPath = implPath.resolve("client");
            }

            if (Files.notExists(srcPath)) {
                Files.createDirectory(srcPath);
            }

            if (Files.notExists(implPath)) {
                Files.createDirectory(implPath);
            }

        }

        List<GenSrcFile> genFiles = generateBalSource(type, definitionPath, reldefinitionPath, serviceName);
        writeGeneratedSources(genFiles, srcPath, implPath, type);
    }

    /**
     * Generates ballerina source for provided Open API Definition in {@code definitionPath}.
     * Generated source will be written to a ballerina module at {@code outPath}
     * Method can be user for generating Ballerina clients.
     *
     * @param executionPath  Command execution path
     * @param definitionPath Input Open Api Definition file path
    // BUG: CWE-306 Missing Authentication for Critical Function
    // 
    // FIXED:
     * @param serviceName    service name
     * @param outPath        Destination file path to save generated source files. If not provided
     *                       {@code definitionPath} will be used as the default destination path
     * @throws IOException               when file operations fail
     * @throws BallerinaOpenApiException when code generator fails
     */
    public void generateClient(String executionPath, String definitionPath, String serviceName, String outPath)
            throws IOException, BallerinaOpenApiException {
        generate(GenType.GEN_CLIENT, executionPath, definitionPath, null, serviceName, outPath);
    }

    /**
     * Generates ballerina source for provided Open API Definition in {@code definitionPath}.
     * Generated source will be written to a ballerina module at {@code outPath}
     * Method can be user for generating Ballerina clients.
     *
     * @param executionPath  Command execution path
     * @param definitionPath Input Open Api Definition file path
     * @param reldefinitionPath Relative definition path to be used in the generated ballerina code
     * @param serviceName    service name for the generated service
     * @param outPath        Destination file path to save generated source files. If not provided
     *                       {@code definitionPath} will be used as the default destination path
     * @throws IOException               when file operations fail
     * @throws BallerinaOpenApiException when code generator fails
     */
    public void generateService(String executionPath, String definitionPath,
                                String reldefinitionPath, String serviceName, String outPath)
            throws IOException, BallerinaOpenApiException {
        generate(GenType.GEN_SERVICE, executionPath, definitionPath, reldefinitionPath, serviceName, outPath);
    }

    /**
     * Generates ballerina source for provided Open API Definition in {@code definitionPath}.
     * Generated code will be returned as a list of source files
     * <p>Method can be user for generating Ballerina mock services and clients</p>
     *
     * @param type           Output type. Following types are supported
     *                       <ul>
     *                       <li>mock</li>
     *                       <li>client</li>
     *                       </ul>
     * @param serviceName    Out put service name
     * @param definitionPath Input Open Api Definition file path
     * @param reldefinitionPath Relative OpenApi File
     * @return a list of generated source files wrapped as {@link GenSrcFile}
     * @throws IOException               when file operations fail
     * @throws BallerinaOpenApiException when open api context building fail
     */
    public List<GenSrcFile> generateBalSource(GenType type, String definitionPath,
                                              String reldefinitionPath, String serviceName)
            throws IOException, BallerinaOpenApiException {
        OpenAPI api = new OpenAPIV3Parser().read(definitionPath);

        if (api == null) {
            throw new BallerinaOpenApiException("Couldn't read the definition from file: " + definitionPath);
        }

        if (serviceName != null) {
            api.getInfo().setTitle(serviceName);
        } else if (api.getInfo() == null || StringUtils.isEmpty(api.getInfo().getTitle())) {
            api.getInfo().setTitle(GeneratorConstants.UNTITLED_SERVICE);
        }

        List<GenSrcFile> sourceFiles;

        switch (type) {
            case GEN_CLIENT:
                // modelPackage is not in use at the moment. All models will be written into same package
                // as other src files.
                // Therefore value set to modelPackage is ignored here
                BallerinaOpenApi definitionContext = new BallerinaOpenApi().buildContext(api).srcPackage(srcPackage)
                        .modelPackage(srcPackage);
                definitionContext.setDefinitionPath(reldefinitionPath);

                sourceFiles = generateClient(definitionContext);
                break;
            case GEN_SERVICE:

                final BallerinaOpenApiType openApi = TypeExtractorUtil.extractOpenApiObject(api);
                openApi.setBalServiceName(serviceName);
                openApi.setBalModule(srcPackage);
                openApi.setServers(api);
                openApi.setTags(api.getTags());

                if (reldefinitionPath == null) {
                    openApi.setDefPath(definitionPath.replaceAll(Pattern.quote("\\"),
                            Matcher.quoteReplacement("\\\\")));
                } else {
                    openApi.setDefPath(reldefinitionPath.replaceAll(Pattern.quote("\\"),
                            Matcher.quoteReplacement("\\\\")));
                }

                sourceFiles = generateBallerinaService(openApi);
                break;
            default:
                return null;
        }

        return sourceFiles;
    }

    /**
     * Write ballerina definition of a <code>object</code> to a file as described by <code>template.</code>
     *
     * @param object       Context object to be used by the template parser
     * @param templateDir  Directory with all the templates required for generating the source file
     * @param templateName Name of the parent template to be used
     * @param outPath      Destination path for writing the resulting source file
     * @throws IOException when file operations fail
     * @deprecated This method is now deprecated.
     * Use {@link #generateBalSource(GeneratorConstants.GenType, String, String, String) generate}
     * and implement a file write functionality your self, if you need to customize file writing steps.
     * Otherwise use {@link #generate(GeneratorConstants.GenType, String, String, String, String, String) generate}
     * to directly write generated source to a ballerina module.
     */
    @Deprecated
    public void writeBallerina(Object object, String templateDir, String templateName, String outPath)
            throws IOException {
        PrintWriter writer = null;

        try {
            Template template = compileTemplate(templateDir, templateName);
            Context context = Context.newBuilder(object).resolver(
                    MapValueResolver.INSTANCE,
                    JavaBeanValueResolver.INSTANCE,
                    FieldValueResolver.INSTANCE).build();
            writer = new PrintWriter(outPath, "UTF-8");
            writer.println(template.apply(context));
        } finally {
            if (writer != null) {
                writer.close();
            }
        }
    }

    private Template compileTemplate(String defaultTemplateDir, String templateName) throws IOException {
        defaultTemplateDir = defaultTemplateDir.replaceAll("\\\\", "/");
        String templatesDirPath = System.getProperty(GeneratorConstants.TEMPLATES_DIR_PATH_KEY, defaultTemplateDir);
        ClassPathTemplateLoader cpTemplateLoader = new ClassPathTemplateLoader((templatesDirPath));
        FileTemplateLoader fileTemplateLoader = new FileTemplateLoader(templatesDirPath);
        cpTemplateLoader.setSuffix(GeneratorConstants.TEMPLATES_SUFFIX);
        fileTemplateLoader.setSuffix(GeneratorConstants.TEMPLATES_SUFFIX);

        Handlebars handlebars = new Handlebars().with(cpTemplateLoader, fileTemplateLoader);
        handlebars.setInfiniteLoops(true); //This will allow templates to call themselves with recursion.
        handlebars.registerHelpers(StringHelpers.class);
        handlebars.registerHelper("equals", (object, options) -> {
            CharSequence result;
            Object param0 = options.param(0);

            if (param0 == null) {
                throw new IllegalArgumentException("found 'null', expected 'string'");
            }
            if (object != null) {
                if (object.toString().equals(param0.toString())) {
                    result = options.fn(options.context);
                } else {
                    result = options.inverse();
                }
            } else {
                result = null;
            }

            return result;
        });

        return handlebars.compile(templateName);
    }

    private void writeGeneratedSources(List<GenSrcFile> sources, Path srcPath, Path implPath, GenType type)
            throws IOException {
        // Remove old generated files - if any - before regenerate
        // if srcPackage was not provided and source was written to main package nothing will be deleted.
        if (srcPackage != null && !srcPackage.isEmpty() && Files.exists(srcPath)) {
            final File[] listFiles = new File(String.valueOf(srcPath)).listFiles();
            if (listFiles != null) {
                Arrays.stream(listFiles).forEach(file -> {
                    boolean deleteStatus = true;
                    if (!file.isDirectory() && !file.getName().equals(MODULE_MD)) {
                        deleteStatus = file.delete();
                    }

                    //Capture return value of file.delete() since if
                    //unable to delete returns false from file.delete() without an exception.
                    if (!deleteStatus) {
                        outStream.println("Unable to clean module directory.");
                    }
                });
            }

        }

        for (GenSrcFile file : sources) {
            Path filePath;

            // We only overwrite files of overwritable type.
            // So non overwritable files will be written to disk only once.
            if (!file.getType().isOverwritable()) {
                filePath = implPath.resolve(file.getFileName());
                if (Files.notExists(filePath)) {
                    CodegenUtils.writeFile(filePath, file.getContent());
                }
            } else {
                filePath = srcPath.resolve(file.getFileName());
                CodegenUtils.writeFile(filePath, file.getContent());
            }
        }

        //This will print the generated files to the console
        if (type.equals(GenType.GEN_SERVICE)) {
            outStream.println("Service generated successfully and the OpenApi contract is copied to " + srcPackage
                    + "/resources. this location will be referenced throughout the ballerina project.");
        } else if (type.equals(GEN_CLIENT)) {
            outStream.println("Client generated successfully.");
        }
        outStream.println("Following files were created. \n" +
                "src/ \n- " + srcPackage);
        Iterator<GenSrcFile> iterator = sources.iterator();
        while (iterator.hasNext()) {
            outStream.println("-- " + iterator.next().getFileName());
        }
    }

    /**
     * Generate code for ballerina client.
     *
     * @param context model context to be used by the templates
     * @return generated source files as a list of {@link GenSrcFile}
     * @throws IOException when code generation with specified templates fails
     */
    private List<GenSrcFile> generateClient(BallerinaOpenApi context) throws IOException {
        if (srcPackage == null || srcPackage.isEmpty()) {
            srcPackage = GeneratorConstants.DEFAULT_CLIENT_PKG;
        }

        List<GenSrcFile> sourceFiles = new ArrayList<>();
        String srcFile = context.getInfo().getTitle().toLowerCase(Locale.ENGLISH)
                .replaceAll(" ", "_") + ".bal";

        // Generate ballerina service and resources.
        String mainContent = getContent(context, GeneratorConstants.DEFAULT_CLIENT_DIR,
                GeneratorConstants.CLIENT_TEMPLATE_NAME);
        sourceFiles.add(new GenSrcFile(GenFileType.GEN_SRC, srcPackage, srcFile, mainContent));

        // Generate ballerina records to represent schemas.
        String schemaContent = getContent(context, GeneratorConstants.DEFAULT_MODEL_DIR,
                GeneratorConstants.SCHEMA_TEMPLATE_NAME);
        sourceFiles.add(new GenSrcFile(GenFileType.MODEL_SRC, srcPackage, GeneratorConstants.SCHEMA_FILE_NAME,
                schemaContent));

        return sourceFiles;
    }

    private List<GenSrcFile> generateBallerinaService(BallerinaOpenApiType api) throws IOException {
        if (srcPackage == null || srcPackage.isEmpty()) {
            srcPackage = GeneratorConstants.DEFAULT_MOCK_PKG;
        }

        List<GenSrcFile> sourceFiles = new ArrayList<>();
        String concatTitle = api.getBalServiceName().toLowerCase(Locale.ENGLISH).replaceAll(" ", "_");
        String srcFile = concatTitle + ".bal";

        String mainContent = getContent(api, GeneratorConstants.DEFAULT_TEMPLATE_DIR + "/service",
                "balService");
        sourceFiles.add(new GenSrcFile(GenFileType.GEN_SRC, srcPackage, srcFile, mainContent));

        String schemaContent = getContent(api, GeneratorConstants.DEFAULT_TEMPLATE_DIR + "/service",
                "schemaList");
        sourceFiles.add(new GenSrcFile(GenFileType.GEN_SRC, srcPackage, GeneratorConstants.SCHEMA_FILE_NAME,
                schemaContent));

        return sourceFiles;
    }

    /**
     * Retrieve generated source content as a String value.
     *
     * @param object       context to be used by template engine
     * @param templateDir  templates directory
     * @param templateName name of the template to be used for this code generation
     * @return String with populated template
     * @throws IOException when template population fails
     */
    private String getContent(BallerinaOpenApiType object, String templateDir, String templateName) throws IOException {
        Template template = compileTemplate(templateDir, templateName);
        Context context = Context.newBuilder(object)
                .resolver(MapValueResolver.INSTANCE, JavaBeanValueResolver.INSTANCE, FieldValueResolver.INSTANCE)
                .build();
        return template.apply(context);
    }

    /**
     * Retrieve generated source content as a String value.
     *
     * @param object       context to be used by template engine
     * @param templateDir  templates directory
     * @param templateName name of the template to be used for this code generation
     * @return String with populated template
     * @throws IOException when template population fails
     */
    private String getContent(BallerinaOpenApi object, String templateDir, String templateName) throws IOException {
        Template template = compileTemplate(templateDir, templateName);
        Context context = Context.newBuilder(object)
                .resolver(MapValueResolver.INSTANCE, JavaBeanValueResolver.INSTANCE, FieldValueResolver.INSTANCE)
                .build();
        return template.apply(context);
    }

    public String getSrcPackage() {
        return srcPackage;
    }

    public void setSrcPackage(String srcPackage) {
        this.srcPackage = srcPackage;
    }

    public String getModelPackage() {
        return modelPackage;
    }

    public void setModelPackage(String modelPackage) {
        this.modelPackage = modelPackage;
    }
}