import java.net.URI

import scala.concurrent.Await
import scala.concurrent.duration.Duration
import slick.basic.DatabaseConfig
import slick.codegen.SourceCodeGenerator
import slick.jdbc.JdbcProfile

trait TableFileGenerator { self: SourceCodeGenerator =>
  def writeTablesToFile(folder: String, pkg: String, fileName: String): Unit
}

trait RowFileGenerator { self: SourceCodeGenerator =>
  def writeRowsToFile(folder: String, pkg: String, fileName: String): Unit
}

object Generator {

  private def outputSchemaCode(
      schemaName: String,
      folder: String,
      pkg: String,
      tableGen: TableFileGenerator,
      rowGen: RowFileGenerator): Unit = {
    val camelSchemaName = schemaName.split('_').map(_.capitalize).mkString("")

    tableGen.writeTablesToFile(folder: String, pkg: String, fileName = s"${camelSchemaName}Tables.scala")
    rowGen.writeRowsToFile(folder: String, pkg: String, fileName = s"${camelSchemaName}Rows.scala")
  }

  def run(
      uri: URI,
      pkg: String,
      schemaNames: Option[List[String]],
      outputPath: String,
      manualForeignKeys: Map[(String, String), (String, String)],
      parentType: Option[String],
      idType: Option[String],
      header: String,
      tablesFileImports: List[String],
      rowsFileImports: List[String],
      typeReplacements: Map[String, String]) = {
    val dc: DatabaseConfig[JdbcProfile] =
      DatabaseConfig.forURI[JdbcProfile](uri)
    val parsedSchemasOpt: Option[Map[String, List[String]]] =
      schemaNames.map(ModelTransformation.parseSchemaList)

    def importStatements(imports: List[String]) = imports.map("import " + _).mkString("\n")

    try {
      val dbModel: slick.model.Model =
        Await.result(dc.db.run(ModelTransformation.createModel(dc.profile, parsedSchemasOpt)), Duration.Inf)

      parsedSchemasOpt.getOrElse(Map.empty).foreach {
        case (schemaName, tables) =>
          val schemaOnlyModel = Await.result(
            dc.db.run(ModelTransformation
              .createModel(dc.profile, Some(Map(schemaName -> tables)))),
            Duration.Inf)

          val rowGenerator = new RowSourceCodeGenerator(
            model = schemaOnlyModel,
            headerComment = header,
            imports = importStatements(rowsFileImports),
            schemaName = schemaName,
            fullDatabaseModel = dbModel,
            idType,
            manualForeignKeys,
            typeReplacements
          )

          val tableGenerator =
            new TableSourceCodeGenerator(
              schemaOnlyModel = schemaOnlyModel,
              headerComment = header,
              imports = importStatements(tablesFileImports),
              schemaName = schemaName,
              fullDatabaseModel = dbModel,
              pkg = pkg,
              manualForeignKeys,
              parentType = parentType,
              idType,
              typeReplacements
            )

          outputSchemaCode(
            schemaName = schemaName,
            folder = outputPath,
            pkg = pkg,
            tableGen = tableGenerator,
            rowGen = rowGenerator)
      }
    } finally {
      dc.db.close()
    }
  }
}