import java.io.File;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import javax.sql.DataSource;

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.io.filefilter.WildcardFileFilter;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.SystemUtils;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;
import org.springframework.context.annotation.PropertySource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;

import ch.vorburger.mariadb4j.DBConfiguration;
import ch.vorburger.mariadb4j.DBConfigurationBuilder;
import ch.vorburger.exec.ManagedProcessException;
import ch.vorburger.mariadb4j.springframework.MariaDB4jSpringService;

@Configuration
public class HomebrewAwareMariaDb4jAutoconfig {
  
  @Bean("mariadbHomebrewBasePath")
  public String mariadbHomebrewBasePath(
      @Value("${mariadb4j.homebrew.basePath:/usr/local/opt}") final String homebrewBasePath,
      @Value("${mariadb4j.homebrew.mariadbBasePath:}") final String mariadbBasePathFromConfig
  ) {
    if (!SystemUtils.IS_OS_MAC) {
      LOGGER.debug("Not running on a Mac, Homebrew not found/supported");
      return "";
    }

    if (StringUtils.isNotBlank(mariadbBasePathFromConfig)) {
      // Who are we to argue?
      LOGGER.debug("Using {} for MariaDB", mariadbBasePathFromConfig);

      return mariadbBasePathFromConfig;
    }

    // Search the standard homebrew path for all MariaDB4j installations
    LOGGER.debug("Finding Homebrew path for MariaDB");

    final File homebrewBase = Paths.get(homebrewBasePath).toFile();
    if (!homebrewBase.exists()) {
      throw new IllegalStateException(
        "Cannot find Homebrew installation on your Mac system, please install and try again"
      );
    }

    final List<String> homebrewBaseFileList = FileUtils
      .listFilesAndDirs(
        homebrewBase,
        new WildcardFileFilter("mariadb*", IOCase.SYSTEM),
        new WildcardFileFilter("mariadb*", IOCase.SYSTEM)
      )
      .stream()
      .map(f -> f.getPath())
      .filter(f -> f.contains("mariadb"))
      .collect(Collectors.toList());

    if (homebrewBaseFileList.isEmpty()) {
      throw new IllegalStateException(
        "Cannot find MariaDB installation from Homebrew, "
        + "please install with `brew install mariadb` or similar and try again"
      );
    }

    if (homebrewBaseFileList.size() > 1) {
      LOGGER.debug("Found more MariaDB candidates than expected: {}", homebrewBaseFileList);

      throw new IllegalStateException(
        "Found multiple MariaDB installations from Homebrew, "
        + "please specify one using the `homebrew.basePath` property"
      );
    }

    final String mariadbBasePath = homebrewBaseFileList.get(0);
    LOGGER.debug("Using MariaDB installation from {}", mariadbBasePath);

    return mariadbBasePath;
  }

  @Bean
  @Primary
  public MariaDB4jSpringService mariaDB4j(
      @Qualifier("mariadbHomebrewBasePath") String mariadbHomebrewBasePath
  ) {
    LOGGER.debug("Creating MariaDB4j service");

    final MariaDB4jSpringService service = new MariaDB4jSpringService();

    if (StringUtils.isNotBlank(mariadbHomebrewBasePath)) {
      // Do whatever customization is desired here
      // service.setDefaultPort(3307);
      service.setDefaultIsUnpackingFromClasspath(false);
      service.setDefaultLibDir(SystemUtils.JAVA_IO_TMPDIR + "/MariaDB4j/no-libs");
      service.setDefaultBaseDir(mariadbHomebrewBasePath);
    }

    return service;
  }

  @Bean
  @Primary
  public DataSource dataSource(
      final MariaDB4jSpringService mariaDB4jSpringService,
      final DataSourceProperties dataSourceProperties,
      @Value("${mariadb4j.databaseName}") final String databaseName
  ) throws ManagedProcessException {
    LOGGER.debug("Creating datasource for MariaDB4j");

    // Create an initial database with default user
    mariaDB4jSpringService.getDB().createDB(databaseName);

    return DataSourceBuilder.create()
      .driverClassName(dataSourceProperties.getDriverClassName())
      .url(dataSourceProperties.getUrl())
      .username(dataSourceProperties.getUsername())
      .password(dataSourceProperties.getPassword())
      .build();
  }

}