/*
 * Copyright (C) 2008-2020, Juick
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package com.juick.config;

import com.juick.*;
import com.juick.model.User;
import com.juick.service.HelpService;
import com.juick.service.SignatureService;
import com.juick.service.StorageService;
import com.juick.service.FileSystemStorageService;
import com.juick.service.UserService;
import com.mitchellbosecke.pebble.extension.FormatterExtension;
import com.overzealous.remark.Options;
import com.overzealous.remark.Remark;

import io.pebbletemplates.pebble.PebbleEngine;
import io.pebbletemplates.pebble.loader.ClasspathLoader;
import io.pebbletemplates.pebble.loader.Loader;
import io.pebbletemplates.spring.extension.SpringExtension;
import io.pebbletemplates.spring.servlet.PebbleViewResolver;

import org.apache.commons.codec.CharEncoding;
import org.commonmark.ext.autolink.AutolinkExtension;
import org.commonmark.node.Link;
import org.commonmark.parser.Parser;
import org.commonmark.renderer.html.HtmlRenderer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.security.web.firewall.HttpStatusRequestRejectedHandler;
import org.springframework.security.web.firewall.RequestRejectedHandler;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.resource.ResourceUrlEncodingFilter;
import org.springframework.web.servlet.resource.ResourceUrlProvider;

import java.util.Collections;
import javax.inject.Inject;

/**
 * Created by aalexeev on 11/22/16.
 */
@Configuration
public class AppConfig {
    @Value("${upload_tmp_dir:#{systemProperties['java.io.tmpdir']}}")
    private String tmpDir;
    @Value("${storage_path:#{systemProperties['java.io.tmpdir']}}")
    private String baseDir;
    @Value("${keystore:classpath:juick-test-key.p12}")
    private Resource keystore;
    @Value("${keystore_password:secret}")
    private String keystorePassword;

    @Bean
    KeystoreManager keystoreManager() {
        return new KeystoreManager(keystore, keystorePassword);
    }

    @Bean
    StorageService storageService() {
        return new FileSystemStorageService(baseDir, tmpDir);
    }

    @Bean
    HelpService helpService() {
        return new HelpService("help");
    }

    @Bean
    Parser cmParser() {
        return Parser.builder().extensions(Collections.singletonList(AutolinkExtension.create())).build();
    }

    @Bean
    HtmlRenderer helpRenderer() {
        return HtmlRenderer.builder()
                .attributeProviderFactory(context -> (node, tagName, attributes) -> {
                    if (node instanceof Link) {
                        Link link = (Link) node;
                        if (link.getDestination().startsWith("/")) {
                            String destination = "/" + helpService().getHelpPath() + link.getDestination();
                            link.setDestination(destination);
                            attributes.put("href", destination);
                        }
                    }
                })
                .build();
    }

    @Bean
    Loader<?> templateLoader() {
        return new ClasspathLoader();
    }

    @Bean
    SpringExtension springExtension() {
        return new SpringExtension(null);
    }

    @Bean
    PebbleEngine pebbleEngine() {
        boolean devToolsArePresent = false;
        try {
            Class.forName("org.springframework.boot.devtools.livereload.Connection");
            devToolsArePresent = true;
        } catch (ClassNotFoundException e) {
            // release mode
        }
        return new PebbleEngine.Builder()
                .loader(this.templateLoader())
                .cacheActive(!devToolsArePresent)
                .extension(springExtension())
                .extension(new FormatterExtension())
                .newLineTrimming(false)
                .strictVariables(true)
                .build();
    }

    @Bean
    ResourceUrlProvider resourceUrlProvider() {
        return new ResourceUrlProvider();
    }

    @Bean
    ResourceUrlEncodingFilter resourceUrlEncodingFilter() {
        return new ResourceUrlEncodingFilter();
    }

    @Bean
    Remark remarkConverter() {
        Options options = new Options();
        options.inlineLinks = true;
        return new Remark(options);
    }

    @Bean
    CommandsManager commandsManager() {
        return new CommandsManager();
    }

    @Bean
    ServerManager serverManager() {
        return new ServerManager();
    }

    @Bean
    SignatureService signatureManager() {
        return new SignatureService(keystoreManager());
    }

    @Bean
    TopManager topManager() {
        return new TopManager();
    }

    @Bean
    ViewResolver viewResolver() {
        PebbleViewResolver viewResolver = new PebbleViewResolver(pebbleEngine());
        viewResolver.setPrefix("templates");
        viewResolver.setSuffix(".html");
        viewResolver.setCharacterEncoding(CharEncoding.UTF_8);
        viewResolver.setExposeRequestAttributes(true);
        return viewResolver;
    }

    @Inject
    private UserService userService;
    @Value("${service_user:juick}")
    private String serviceUsername;
    @Value("${archive_user:archive}")
    private String archiveUsername;

    @Bean
    User serviceUser() {
        return userService.getUserByName(serviceUsername);
    }

    @Bean
    User archiveUser() {
        return userService.getUserByName(archiveUsername);
    }

    @Bean
    RequestRejectedHandler requestRejectedHandler() {
        return new HttpStatusRequestRejectedHandler();
    }
}