package cbt
import cbt.paths._

import java.io._
import java.lang.reflect.InvocationTargetException
import java.net._
import java.nio.file.{Path =>_,_}
import java.nio.file.Files.readAllBytes
import java.security.MessageDigest
import java.util.jar._

import scala.collection.immutable.Seq
import scala.reflect.runtime.{universe => ru}
import scala.util._

import ammonite.ops.{cwd => _,_}

class BasicBuild(context: Context) extends Build(context)
class Build(val context: Context) extends Dependency with TriggerLoop{
  // library available to builds
  final val logger = context.logger
  override final protected val lib: Lib = new Lib(logger)
  
  // ========== general stuff ==========

  def enableConcurrency = false
  final def projectDirectory: File = context.cwd
  assert( projectDirectory.exists, "projectDirectory does not exist: " ++ projectDirectory.string )
  final def usage: Unit = new lib.ReflectBuild(this).usage
/*
  def scaffold: Unit = lib.generateBasicBuildFile(
    projectDirectory, scalaVersion, groupId, artifactId, version
  )
*/
  // ========== meta data ==========

  def scalaVersion: String = constants.scalaVersion
  final def scalaMajorVersion: String = scalaVersion.split("\\.").take(2).mkString(".")
  def zincVersion = "0.3.9"

  def dependencies: Seq[Dependency] = Seq(
    "org.scala-lang" % "scala-library" % scalaVersion
  )

  // ========== paths ==========
  final private val defaultSourceDirectory = projectDirectory ++ "/src"

  /** base directory where stuff should be generated */
  def target: File = projectDirectory ++ "/target"
  /** base directory where stuff should be generated for this scala version*/
  def scalaTarget: File = target ++ s"/scala-$scalaMajorVersion"
  /** directory where jars (and the pom file) should be put */
  def jarTarget: File = scalaTarget
  /** directory where the scaladoc should be put */
  def apiTarget: File = scalaTarget ++ "/api"
  /** directory where the class files should be put (in package directories) */
  def compileTarget: File = scalaTarget ++ "/classes"

  /** Source directories and files. Defaults to .scala and .java files in src/ and top-level. */
  def sources: Seq[File] = Seq(defaultSourceDirectory) ++ projectDirectory.listFiles.toVector.filter(sourceFileFilter)

  /** Which file endings to consider being source files. */
  def sourceFileFilter(file: File): Boolean = file.toString.endsWith(".scala") || file.toString.endsWith(".java")

  /** Absolute path names for all individual files found in sources directly or contained in directories. */
  final def sourceFiles: Seq[File] = for {
    base <- sources.filter(_.exists).map(lib.realpath)
    file <- lib.listFilesRecursive(base) if file.isFile && sourceFileFilter(file)
  } yield file

  protected def assertSourceDirectories(): Unit = {
    val nonExisting =
      sources
        .filterNot( _.exists )
        .diff( Seq(defaultSourceDirectory) )
    assert(
      nonExisting.isEmpty,
      "Some sources do not exist: \n"++nonExisting.mkString("\n")
    )
  }
  assertSourceDirectories()


  /** SBT-like dependency builder DSL */
  class GroupIdAndArtifactId( groupId: String, artifactId: String ){
    def %(version: String) = new MavenDependency(groupId, artifactId, version)(lib.logger)
  }
  implicit class DependencyBuilder(groupId: String){
    def %%(artifactId: String) = new GroupIdAndArtifactId( groupId, artifactId++"_"++scalaMajorVersion )
    def  %(artifactId: String) = new GroupIdAndArtifactId( groupId, artifactId )
  }

  final def BuildDependency(path: File) = cbt.BuildDependency(
    context.copy( cwd = path, args = Seq() )
  )

  def triggerLoopFiles: Seq[File] = sources ++ transitiveDependencies.collect{ case b: TriggerLoop => b.triggerLoopFiles }.flatten
  
  def localJars           : Seq[File] =
    Seq(projectDirectory ++ "/lib")
      .filter(_.exists)
      .flatMap(_.listFiles)
      .filter(_.toString.endsWith(".jar"))

  //def cacheJar = false
  override def dependencyClasspath : ClassPath = ClassPath(localJars) ++ super.dependencyClasspath
  override def dependencyJars      : Seq[File] = localJars ++ super.dependencyJars

  def exportedClasspath   : ClassPath = ClassPath(Seq(compile))
  def exportedJars: Seq[File] = Seq()
  // ========== compile, run, test ==========

  /** scalac options used for zinc and scaladoc */
  def scalacOptions: Seq[String] = Seq( "-feature", "-deprecation", "-unchecked" )

  val updated: Boolean = {
    val existingClassFiles = lib.listFilesRecursive(compileTarget)
    val sourcesChanged = existingClassFiles.nonEmpty && {
      val oldestClassFile = existingClassFiles.sortBy(_.lastModified).head
      val oldestClassFileAge = oldestClassFile.lastModified
      val changedSourceFiles = sourceFiles.filter(_.lastModified > oldestClassFileAge)
      if(changedSourceFiles.nonEmpty){
        /*
        println(changedSourceFiles)
        println(changedSourceFiles.map(_.lastModified))
        println(changedSourceFiles.map(_.lastModified > oldestClassFileAge))
        println(oldestClassFile)
        println(oldestClassFileAge)
        println("-"*80)
        */
      }
      changedSourceFiles.nonEmpty
    }
    sourcesChanged || transitiveDependencies.map(_.updated).fold(false)(_ || _)
  }
 
  private object cacheCompileBasicBuild extends Cache[File]
  def compile: File = cacheCompileBasicBuild{
    //println(transitiveDependencies.filter(_.updated).mkString("\n"))
    lib.compile(
      updated,
      sourceFiles, compileTarget, dependencyClasspath, scalacOptions,
      zincVersion = zincVersion, scalaVersion = scalaVersion
    )
  }

  def runClass: String = "Main"
  def run: ExitCode = lib.runMainIfFound( runClass, context.args, classLoader ) 

  def test: ExitCode = lib.test(context)

  context.logger.composition(">"*80)
  context.logger.composition("class   " ++ this.getClass.toString)
  context.logger.composition("dir     " ++ context.cwd.string)
  context.logger.composition("sources " ++ sources.toList.mkString(" "))
  context.logger.composition("target  " ++ target.string)
  context.logger.composition("context " ++ context.toString)
  context.logger.composition("dependencyTree\n" ++ dependencyTree)
  context.logger.composition("<"*80)

  // ========== cbt internals ==========
  private[cbt] def finalBuild = this
  override def show = this.getClass.getSimpleName ++ "(" ++ context.cwd.string ++ ")"
}