package ex09

import java.time.LocalDateTime
import java.time.ZoneOffset
import java.time.format.DateTimeFormatter
import java.time.Duration
import java.time.Instant
import java.time.temporal.ChronoUnit

import de.tudarmstadt.stg.sedc.annotations.builder.ConcreteBuilder
import de.tudarmstadt.stg.sedc.annotations.composite.{ChildManagement, Composite, Leaf}
import de.tudarmstadt.stg.sedc.annotations.decorator.{ConcreteComponent, ConcreteDecorator}
import de.tudarmstadt.stg.sedc.annotations.visitor.{ConcreteElement, ConcreteVisitor, Element}

@Element
trait Visitable {
    def accept(visitor: Visitor)
}

@de.tudarmstadt.stg.sedc.annotations.visitor.Visitor
trait Visitor {
    def visit(simpleTask: SimpleTask)
    def visit(dependentTask: DependentTask)
    def visit(billableTask: BillableTask)
    def visit(project: Project)
}

@ConcreteVisitor
class InvoiceVisitor extends Visitor {
    var totalInvoice: String = ""

    override def visit(simpleTask: SimpleTask): Unit = {}

    override def visit(dependentTask: DependentTask): Unit = {}

    override def visit(billableTask: BillableTask): Unit = {
        totalInvoice.concat(billableTask.description + ": " + billableTask.rate * billableTask.duration.get(ChronoUnit.HOURS))
    }

    override def visit(project: Project): Unit = {
        for(task: Task <- project.list)
            task match {
                case a: BillableTask => visit(a)
                case _ => ()
            }
    }

    def getInvoice: String = totalInvoice
}

@ConcreteVisitor
class ValidationVisitor extends Visitor {
    var consistent = true

    override def visit(simpleTask: SimpleTask): Unit = {}

    override def visit(dependentTask: DependentTask): Unit = {
        if(dependentTask.aTask.dueDate.get.compareTo(dependentTask.anotherTask.dueDate.get) >= 0)
            consistent = false
    }

    override def visit(billableTask: BillableTask): Unit = {}

    override def visit(project: Project): Unit = {
        for(task: Task <- project.list)
            task match {
                case a: DependentTask => visit(a)
                case _ => ()
            }
    }

    def isConsistent: Boolean = {false}
}

@ConcreteVisitor
class NextDeadlineVisitor extends Visitor {
    override def visit(simpleTask: SimpleTask): Unit = {}

    override def visit(dependentTask: DependentTask): Unit = {}

    override def visit(billableTask: BillableTask): Unit = {}

    override def visit(project: Project): Unit = {}

    def getNextDeadline: Instant = Instant.MAX
}

trait Task extends Visitable{
    def description: String

    def duration: Duration

    def dueDate: Option[Instant]

    def completionDate: Option[Instant]

    def startDate: Option[Instant]

    def context: Option[String]

    def priority: Option[Char]

    def markDone(): Unit

    def addTime(duration: Duration): Unit
}


trait OutputFormat {

    def format(visitables: List[Visitable]): String

    protected def printInstantAsDate(instant: Instant): String = {
        val datetime = LocalDateTime.ofInstant(instant, ZoneOffset.UTC)
        DateTimeFormatter.ofPattern("yyyy-MM-dd").format(datetime)
    }
}

trait Export[T] {
    def result: T
}

@ConcreteComponent
@Leaf
@ConcreteElement
case class SimpleTask(description: String, dueDate: Option[Instant], context: Option[String], priority: Option[Char], startDate: Option[Instant]) extends Task {
    var _completeDate: Option[Instant] = None

    override def duration: Duration = Duration.ZERO

    override def completionDate: Option[Instant] = _completeDate

    override def markDone(): Unit = _completeDate = Some(Instant.now)

    override def addTime(duration: Duration): Unit = this.duration.plus(duration)

    override def accept(visitor: Visitor): Unit = visitor.visit(this)
}

@ConcreteDecorator
@Leaf
@ConcreteElement
case class DependentTask(aTask: Task, anotherTask: Task) extends Task {
    override def description: String = aTask.description

    override def duration: Duration = aTask.duration

    override def dueDate: Option[Instant] = aTask.dueDate

    override def completionDate: Option[Instant] = aTask.completionDate

    override def startDate: Option[Instant] = aTask.startDate

    override def context: Option[String] = aTask.context

    override def priority: Option[Char] = aTask.priority

    override def markDone(): Unit = aTask.markDone()

    override def addTime(duration: Duration): Unit = aTask.addTime(duration)

    override def accept(visitor: Visitor): Unit = visitor.visit(this)
}

@ConcreteDecorator
@Leaf
@ConcreteElement
case class BillableTask(aTask: Task, rate: Double) extends Task {
    override def description: String = aTask.description

    override def duration: Duration = aTask.duration

    override def dueDate: Option[Instant] = aTask.dueDate

    override def completionDate: Option[Instant] = aTask.completionDate

    override def startDate: Option[Instant] = aTask.startDate

    override def context: Option[String] = aTask.context

    override def priority: Option[Char] = aTask.priority

    override def markDone(): Unit = aTask.markDone()

    override def addTime(duration: Duration): Unit = aTask.addTime(duration)

    override def accept(visitor: Visitor): Unit = visitor.visit(this)
}


@ConcreteBuilder
class TaskBuilder(private var description: String) {
    private var dueDate: Option[Instant] = None
    private var context: Option[String] = None
    private var priority: Option[Char] = None
    private var dependence: Option[Task] = None
    private var rate: Option[Double] = None
    private var startDate: Option[Instant] = None

    def addDueDate(instant: Instant): TaskBuilder = {
        require(this.dueDate.isEmpty)
        dueDate = Some(instant)
        this
    }

    def addContext(context: String): TaskBuilder = {
        require(this.context.isEmpty)
        this.context = Some(context)
        this
    }

    def addPriority(prio: Char): TaskBuilder = {
        require(priority.isEmpty)
        require(prio >= 'A' && prio <= 'Z')
        this.priority = Some(prio)
        this
    }

    def addDependency(task: Task): TaskBuilder = {
        require(dependence.isEmpty)
        dependence = Some(task)
        this
    }

    def addRate(rate: Double): TaskBuilder = {
        require(this.rate.isEmpty)
        this.rate = Some(rate)
        this
    }

    def addStartDate(startDate:Instant): TaskBuilder = {
        require(this.startDate.isEmpty)
        this.startDate = Some(startDate)
        this
    }

    def build(): Task =  {
        if(this.startDate.isEmpty)
            this.startDate = Some(Instant.now)

        if(this.dependence.isDefined)
            DependentTask(SimpleTask(description, dueDate, context, priority, startDate), this.dependence.get)
        else if (this.rate.isDefined)
            BillableTask(SimpleTask(description, dueDate, context, priority, startDate), this.rate.get)
        else
            SimpleTask(description, dueDate, context, priority, startDate)
    }
}

@Composite
@ConcreteElement
class Project private(val name: String) extends Visitable {
    var list: Seq[Task] = Nil

    def initialize(tasks: Seq[Task]) = list = tasks

    @ChildManagement
    def add(task: Task): Unit = list = list :+ task

    @ChildManagement
    def remove(index: Int): Unit = list.patch(index, Nil, 1)

    override def accept(visitor: Visitor): Unit = visitor.visit(this)
}

object Project {
    def create(name: String, tasks: Task*): Project = {
        val aProject: Project = new Project(name)
        aProject.initialize(tasks)
        aProject
    }
}

class TaskList(t: List[Visitable], val f: OutputFormat) extends Export[String] {
    def result: String = ???
}

case object TodoTXT

case object CSV

object Runner {

    def main(args: Array[String]): Unit = {
        var list = new TaskBuilder("task1").build() :: Nil
        list = new TaskBuilder("task2").addDependency(list.head).addDueDate(Instant.now().plus(6,
            ChronoUnit.DAYS)).build() :: list
        list = new TaskBuilder("task3").addContext("phone").addDueDate(Instant.now().plus(5,
            ChronoUnit.DAYS)).build() :: list
        list = new TaskBuilder("task4").addPriority('A').addRate(10.0).build() :: list
        list = new TaskBuilder("task5").addContext("phone").addRate(10.0).addPriority('B')
            .addDueDate(Instant.now().plus(5, ChronoUnit.DAYS)).addDependency(list(1)).build() :: list
        list.head.addTime(Duration.of(8L, ChronoUnit.HOURS))
        list.head.markDone()
        list = list.reverse
        val project = Project.create("all", list: _*)

        var visitableList:List[Visitable] = new TaskBuilder("task6").addContext("phone").addRate(10.0)
            .addPriority('B')
            .addDueDate(Instant.now().plus(5, ChronoUnit.DAYS))
            .addDependency(list(4)).build() :: Nil
        visitableList = project :: visitableList

//        println(new TaskList(visitableList, CSV).result)
//        println(new TaskList(visitableList, TodoTXT).result)

        val invoiceVisitor = new InvoiceVisitor
        val deadlineVisitor = new NextDeadlineVisitor
        val validationVisitor = new ValidationVisitor


        project.accept(invoiceVisitor)
        project.accept(deadlineVisitor)
        project.accept(validationVisitor)

        println(invoiceVisitor.getInvoice)
        println(deadlineVisitor.getNextDeadline)
        println(validationVisitor.isConsistent)
    }

}