package net.conejos.communication

import com.rabbitmq.client._

object Builder {

  abstract class Builder(val name : String) {
    type BuilderType <: Builder
    val self : BuilderType
    
    protected  var _durable : Boolean = false
    protected  var _autoDelete : Boolean = false
 
    def durable : BuilderType = {
      _durable = true
      self
    }
   
     def autoDelete : BuilderType = {
      _autoDelete = true
      self
    }

     def declare (implicit chann : Channel) : String
  }
  
  object ExchangeBuilder {
  
    private [ExchangeBuilder] def builder (name : String, _type : String) : ExchangeBuilder = new ExchangeBuilder(name, _type)
  
    def direct(name : String) = builder(name, "direct")
    def fanout(name : String) = builder(name, "fanout")
  
    class ExchangeBuilder(name : String, val _type : String) extends Builder(name) {
      type BuilderType = ExchangeBuilder
      val self = this
      def declare (implicit chann : Channel) = {
        chann.exchangeDeclare(name, _type, false, _durable, _autoDelete, null)
        name
      }
    } 
  
  }


  object QueueBuilder {
  
    private [QueueBuilder] def builder (name: String, exclusive : Boolean) : QueueBuilder = new QueueBuilder(name, exclusive)
    
    //init an exclusive queue builder
    def exclusive(n : String) = builder(n, true)
    //init a non-exclusive queue builder
    def nonExclusive(n : String) = builder(n, false)
  
    class QueueBuilder(name : String, val _exclusive : Boolean) extends Builder(name)  {
      type BuilderType = QueueBuilder
      val self = this
      
      def declare(implicit chann : Channel) : String = {
        chann.queueDeclare(name, false, _durable, _exclusive, _autoDelete, null).getQueue
        
      }
      
    }
  }
  
  
}