package com;

import com.alibaba.druid.filter.stat.StatFilter;
import com.alibaba.druid.util.JdbcConstants;
import com.alibaba.druid.wall.WallFilter;
import com.alibaba.fastjson.JSONObject;
import com.common.annotation.JfinalModelScan;
import com.common.annotation.Table;
import com.common.component.DruidPlugin;
import com.common.component.RedisCache;
import com.common.configure.JfinalProperties;
import com.common.core.utils.KitClassUtils;
import com.common.core.utils.SecretsManagerUtils;
import com.common.core.utils.SpringContextUtils;
import com.jfinal.plugin.activerecord.ActiveRecordPlugin;
import com.jfinal.plugin.activerecord.CaseInsensitiveContainerFactory;
import com.jfinal.plugin.activerecord.IContainerFactory;
import com.jfinal.plugin.activerecord.cache.ICache;
import com.jfinal.plugin.activerecord.dialect.*;
import com.jfinal.template.source.StringSource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.jdbc.DatabaseDriver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.*;


/**
 * @author 廖振钦
 * @Date 2022-01-11 10:24
 * */

@Slf4j
@Configuration
@SpringBootApplication(exclude ={DataSourceAutoConfiguration.class} )
@JfinalModelScan(basePackages = {"com.deloitte"})
@EnableAsync
@EnableScheduling // 开启定时任务功能
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        log.info("(♥◠‿◠)ﾉﾞ  系统启动成功   ლ(´ڡ`ლ)ﾞ  \n");
        log.info("swagger文档地址  http://"+getHost()+":"+SpringContextUtils.getEnvParam("server.port")+SpringContextUtils.getEnvParam("server.servlet.context-path")+"/doc.html");
    }

    public static String getHost(){
        try {
            InetAddress addr = InetAddress.getLocalHost();
            return addr.getHostAddress();
        } catch (UnknownHostException e) {
            log.error("启动失败",e);
        }
        return "";
    }


    private Map<DatabaseDriver, Dialect> dialectMap = new HashMap<>();

    @Autowired
    private Environment env;

    @Autowired
    private JfinalProperties jfinalProperties;

    @Autowired
    private SecretsManagerUtils secretsManagerUtils;

    @Bean
    public DruidPlugin getDruidPlugin(){
        System.setProperty("druid.mysql.usePingMethod", "false");
        JSONObject object = secretsManagerUtils.getSecret(env.getProperty("aws.secrets.mysql"));
        String port = object.getString("port");
        String host = object.getString("host");
        String dbname = object.getString("dbname");
        String username = object.getString("username");
        String password = object.getString("password");
        String url = "jdbc:mysql://" + host + ":" + port + "/" + dbname + "?characterEncoding=utf8&useSSL=true&zeroDateTimeBehavior=convertToNull&tinyInt1isBit=false&useUnicode=true&serverTimezone=Asia/Shanghai";
        DruidPlugin dbPlugin=new DruidPlugin(url , username, password);
        // 配置防火墙加强数据库安全
        WallFilter wallFilter = new WallFilter();
        wallFilter.setDbType(JdbcConstants.MYSQL);
        dbPlugin.addFilter(wallFilter);

        //配置监控
        StatFilter statFilter=new StatFilter();
        statFilter.setMergeSql(true);
        statFilter.setLogSlowSql(true);
        statFilter.setSlowSqlMillis(1500);

        // 添加 StatFilter 才会有统计数据
        dbPlugin.addFilter(statFilter);
        dbPlugin.start();
        return dbPlugin;
    }

    @Bean
    @ConditionalOnMissingBean(ICache.class)
    @ConditionalOnClass(name = "org.springframework.cache.CacheManager")
    public ICache cache() {
        return SpringContextUtils.getBean(RedisCache.class);
    }

    @Bean
    @ConditionalOnMissingBean(IContainerFactory.class)
    public IContainerFactory containerFactory() {
        // 不区分大小写 但是最后字段名统一小写
        return new CaseInsensitiveContainerFactory(true);
    }

    @Bean
    public ActiveRecordPlugin activeRecordPlugin(ICache cache,
                                                 DruidPlugin dataSource,
                                      IContainerFactory containerFactory) {
        dialectMap.put(DatabaseDriver.MYSQL, new MysqlDialect());
        dialectMap.put(DatabaseDriver.ORACLE, new OracleDialect());
        dialectMap.put(DatabaseDriver.SQLSERVER, new SqlServerDialect());
        dialectMap.put(DatabaseDriver.SQLITE, new Sqlite3Dialect());
        dialectMap.put(DatabaseDriver.POSTGRESQL, new PostgreSqlDialect());
        ActiveRecordPlugin activeRecordPlugin = new ActiveRecordPlugin(dataSource);
        activeRecordPlugin.setCache(cache);
        try {
            DatabaseDriver databaseDriver = DatabaseDriver.fromJdbcUrl(dataSource.getDataSource().getConnection().getMetaData().getURL());
            Dialect dialect;
            if (!ObjectUtils.isEmpty(jfinalProperties.getDialect())) {
                dialect = jfinalProperties.getDialect().newInstance();
            } else {
                dialect = dialectMap.get(databaseDriver);
            }
            if (ObjectUtils.isEmpty(dialect)) {
                throw new IllegalArgumentException("dialect not be found!");
            }
            activeRecordPlugin.setDialect(dialect);
        } catch (Exception e) {
            log.error("启动失败",e);
        }
        if (!ObjectUtils.isEmpty(jfinalProperties.getShowSql())) {
            activeRecordPlugin.setShowSql(jfinalProperties.getShowSql());
        }
        if (!ObjectUtils.isEmpty(jfinalProperties.getDevMode())) {
            activeRecordPlugin.setDevMode(jfinalProperties.getDevMode());
        }
        if (!ObjectUtils.isEmpty(jfinalProperties.getTransactionLevel())) {
            activeRecordPlugin.setTransactionLevel(jfinalProperties.getTransactionLevel());
        }
        activeRecordPlugin.setContainerFactory(containerFactory);
        getSqlTemplates(activeRecordPlugin, jfinalProperties.getSqlTemplates());
        getMappingKet(activeRecordPlugin, jfinalProperties.getKitClasses());
        autoMappingTable(activeRecordPlugin);
        activeRecordPlugin.start();
        return activeRecordPlugin;
    }

    private void autoMappingTable(ActiveRecordPlugin activeRecordPlugin){
        KitClassUtils.tableclass.forEach(clazz->{
            Table table = (Table)clazz.getAnnotation(Table.class);
            activeRecordPlugin.addMapping(table.tableName(), table.primaryKey(), table.clazz());
        });
    }

    private void getSqlTemplates(ActiveRecordPlugin arp, List<String> sqlTemplates) {
        ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();
        List<Resource> resources = new ArrayList<Resource>();
        if (!ObjectUtils.isEmpty(sqlTemplates)) {
            sqlTemplates.forEach(sqlTemplate -> {
                if (sqlTemplate != null) {
                    try {
                        Resource[] templates = resourceResolver.getResources(sqlTemplate);
                        resources.addAll(Arrays.asList(templates));
                    } catch (IOException e) {
                        log.warn("{} path not found in classpath", sqlTemplate);
                    }
                    resources.forEach(resource -> {
                        StringBuilder content = null;
                        try {
                            content = getContentByStream(resource.getInputStream());
                            arp.addSqlTemplate(new StringSource(content, true));
                        } catch (IOException e) {
                            log.error("启动失败",e);
                        }
                    });
                }
            });
        }
    }

    private void getMappingKet(ActiveRecordPlugin activeRecordPlugin, List<String> kitClasses) {
        if (!ObjectUtils.isEmpty(kitClasses)) {
            kitClasses.forEach(kitClass -> {
                try {
                    Class<?> mappingKitClass = Class.forName(kitClass);
                    Object mappingKit = mappingKitClass.newInstance();
                    Method mappingMethod = ReflectionUtils.findMethod(mappingKitClass, "mapping",
                            activeRecordPlugin.getClass());
                    ReflectionUtils.invokeMethod(mappingMethod, mappingKit, activeRecordPlugin);
                } catch (Exception e) {
                    log.warn("{} not found in classpath", kitClass);
                }
            });
        }
    }

    private StringBuilder getContentByStream(InputStream inputStream) {
        StringBuilder stringBuilder = new StringBuilder();
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
            String line;
            while ((line = br.readLine()) != null) {
                stringBuilder.append(line);
            }
        } catch (Exception e) {
            log.error("启动失败",e);
        }
        return stringBuilder;
    }

}