/*
 * Copyright (C) 2008-2019, 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.service.HelpService;
import com.mitchellbosecke.pebble.PebbleEngine;
import com.mitchellbosecke.pebble.extension.FormatterExtension;
import com.mitchellbosecke.pebble.loader.ClasspathLoader;
import com.mitchellbosecke.pebble.loader.Loader;
import com.mitchellbosecke.pebble.spring.extension.SpringExtension;
import com.mitchellbosecke.pebble.spring.servlet.PebbleViewResolver;
import com.overzealous.remark.Options;
import com.overzealous.remark.Remark;
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.cache.annotation.EnableCaching;
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.Resource;
import org.springframework.http.CacheControl;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.web.servlet.ViewResolver;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.resource.ResourceUrlEncodingFilter;
import org.springframework.web.servlet.resource.VersionResourceResolver;

import java.net.MalformedURLException;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.concurrent.TimeUnit;

/**
 * Created by aalexeev on 11/22/16.
 */
@Configuration
@EnableCaching
@EnableAsync(proxyTargetClass = true)
@EnableScheduling
public class WebConfig implements WebMvcConfigurer {
    @Value("${img_path:#{systemEnvironment['TEMP'] ?: '/tmp'}}")
    private String imgDir;
    @Bean
    public CaffeineCacheManager cacheManager() {
        return new CaffeineCacheManager("help");
    }

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

    @Bean
    public Parser cmParser() {
        return Parser.builder().extensions(Collections.singletonList(AutolinkExtension.create())).build();
    }
    @Bean
    public 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
    public Loader templateLoader() {
        return new ClasspathLoader();
    }

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

    @Bean
    public 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();
    }

    @Value("${keystore:classpath:juick-test-key.p12}")
    private Resource keystore;
    @Value("${keystore_password:secret}")
    private String keystorePassword;
    @Bean
    public ResourceUrlEncodingFilter resourceUrlEncodingFilter() {
        return new ResourceUrlEncodingFilter();
    }
    @Bean
    public KeystoreManager keystoreManager() {
        return new KeystoreManager(keystore, keystorePassword);
    }
    @Bean
    public Remark remarkConverter() {
        Options options = new Options();
        options.inlineLinks = true;
        return new Remark(options);
    }
    @Bean
    public CommandsManager commandsManager() {
        return new CommandsManager();
    }
    @Bean
    public ServerManager serverManager() {
        return new ServerManager();
    }
    @Bean
    public SignatureManager signatureManager() {
        return new SignatureManager();
    }
    @Bean
    public TopManager topManager() {
        return new TopManager();
    }

    @Bean
    public ViewResolver viewResolver() {
        PebbleViewResolver viewResolver = new PebbleViewResolver();
        viewResolver.setPrefix("templates");
        viewResolver.setSuffix(".html");
        viewResolver.setPebbleEngine(pebbleEngine());
        viewResolver.setCharacterEncoding(CharEncoding.UTF_8);
        return viewResolver;
    }
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        try {
            registry
                    .addResourceHandler("/**", "/i/a/**")
                    .addResourceLocations("classpath:/static/", Paths.get(imgDir, "/a/").toUri().toURL().toString())
                    .setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS))
                    .resourceChain(false)
                    .addResolver(new VersionResourceResolver().addContentVersionStrategy("/**", "/i/a/**"));
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

}