package drivers
import (
	// Core
	"log"
	"os"
	"time"
	// Third party
	"github.com/streadway/amqp"
)
type Queue struct {
	Channel *amqp.Channel
}
func NewQueue() *Queue {
	return &Queue{}
}
// Queue interface
type IQueue interface {
	Connect(args ...interface{})
	Publish(queue string, payload []byte) error
	Listen(queue string) (<-chan amqp.Delivery, error)
	Declare(queue string) (amqp.Queue, error)
}
// Connect - Connects to RabbitMQ
func (queue *Queue) Connect(args ...interface{}) {
	var uri string
	if args == nil {
		// Get from env vars
		uri = os.Getenv("RABBIT_MQ_URI")
		if uri == "" {
			log.Panic("No uri for queue given")
		}
	} else {
		uri = args[0].(string)
	}
	// Make max 5 connection attempts, with a 1 second timeout
	for i := 0; i < 5; i++ {
		log.Println("Connecting to:", uri)
		// If connection is successful, return new instance
		conn, err := amqp.Dial(uri)
        defer conn.Close()
		if err == nil {
			log.Println("Successfully connected to queue!")
			channel, _ := conn.Channel()
			queue.Channel = channel
			return
		}
		log.Println("Failed to connect to queue, retrying...", err)
		// Wait 1 second
		time.Sleep(5 * time.Second)
	}
}
// Declare a new queue
func (queue *Queue) Declare(queueName string) (amqp.Queue, error) {
	return queue.Channel.QueueDeclare(
		queueName,
		true,
		false,
		false,
		false,
		nil,
	)
}
// Publish a message
func (queue *Queue) Publish(queueName string, payload []byte) error {
	return queue.Channel.Publish(
		"",
		queueName,
		false,
		false,
		amqp.Publishing{
			DeliveryMode: amqp.Persistent,
			ContentType:  "application/json",
			Body:         payload,
		},
	)
}
// Listen for a new message
func (queue *Queue) Listen(queueName string) (<-chan amqp.Delivery, error) {
	return queue.Channel.Consume(
		queueName,
		"",
		true,
		false,
		false,
		false,
		nil,
	)
}

type Queue struct {
    // your original fields
    Conn amqp.Connection
}
// Somewhere else
queue.Conn.Close()

func action(conn amqp.Connection, args ...interface{}) (<-chan bool) {
    done := make(chan bool)
    go func(amqpConn amqp.Connection, dChan chan bool){
        // Do what you want with the connection
        dChan <- true
    }(conn, done)
    return done
}
func (queue *Queue) Connect(args ...interface{}) {
     // your connection code
     doneChans := make([](chan bool), 5)
     for i := 0; i < 5; i++ {
          conn, err := amqp.Dial(uri)
          defer conn.Close()
          if err != nil {
              // handle error
          }
          done := action(conn)
     }
     // This for loop will block until the 5 action calls are done
     for j := range doneChans {
         isFinish := <-doneChans[j]
         if !isFinish {
             // handle bad state
         }
     }
}

package driver
// imports, etc
func (queue *Queue) Connect(args ...interface{}) amqp.Connection, error {
    // ...
    conn, err := amqp.Dial(uri)
    if err != nil {
        return nil, err
    }
    // ...
    return conn, nil
}

package stuff
// imports, etc
func doStuff() {
    queue = driver.NewQueue()
    conn, err := queue.Connect(args...)
    if err != nil {
        log.Fatalf("oh no! %v!", err)
    }
    defer conn.Close()
    // Do stuff
}