package verbose

import (
	"github.com/dotcloud/docker/api/client"
	"bufio"
  "fmt"
  "io"
  "time"
  "testing"
	"strings"

)



const (
        unitTestImageName        = "docker-test-image"
        unitTestImageID          = "83599e29c455eb719f77d799bc7c51521b9551972f5a850d7ad265bc1b5292f6" // 1.0
        unitTestImageIDShort     = "83599e29c455"
        unitTestNetworkBridge    = "testdockbr0"
        unitTestStoreBase        = "/var/lib/docker/unit-tests"
        testDaemonAddr           = "172.17.8.100:4243"
        testDaemonProto          = "tcp"
        testDaemonHttpsProto     = "tcp"
        testDaemonHttpsAddr      = "localhost:4271"
        testDaemonRogueHttpsAddr = "localhost:4272"
)

func closeWrap(args ...io.Closer) error {
	e := false
	ret := fmt.Errorf("Error closing elements")
	for _, c := range args {
		if err := c.Close(); err != nil {
			e = true
			ret = fmt.Errorf("%s\n%s", ret, err)
		}
	}
	if e {
		return ret
	}
	return nil
}


func getIPAdressTest(t *testing.T) string{
	stdin, _   := io.Pipe()
	stdout, stdoutPipe := io.Pipe()
	cli := client.NewDockerCli(nil, stdoutPipe, nil, testDaemonProto, testDaemonAddr, nil)
	var IPAdress string
	go func(){
		err:= cli.CmdInspect("--format","{{ .NetworkSettings.IPAddress }}","deis-etcd")
		if err != nil {
			t.Fatalf("getIPAdressTest %s",err)
		}
		if err = closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("getIPAdressTest %s",err)
		}
	}()
	time.Sleep(2000 * time.Millisecond)
	for{
		if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
			IPAdress=cmdBytes
			fmt.Println(cmdBytes)
		}else{
			break
		}
		fmt.Println("get IPAddress")
	}
	return IPAdress
}




func pullEtcdTest(t *testing.T,done chan bool){
	stdin, _   := io.Pipe()
	stdout, stdoutPipe := io.Pipe()
	fmt.Println("1")
	cli := client.NewDockerCli(nil, stdoutPipe, nil, testDaemonProto, testDaemonAddr, nil)
	fmt.Println("2")
	go func (){
		err:= cli.CmdPull("phife.atribecalledchris.com:5000/deis/etcd:0.3.0")
		if err != nil {
			t.Fatalf("pullEtcdTest %s",err)
		}
		if err = closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("pullEtcdTest %s",err)
		}
	}( )
	time.Sleep(3000 * time.Millisecond)
	for{
		if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
		fmt.Println(cmdBytes)
		}else{
			break
		}
		fmt.Println("pulling etcd")
	}
	done<-true

}

func runEtcdTest(t *testing.T,done chan bool){
	stdin, _   := io.Pipe()
	stdout, stdoutPipe := io.Pipe()
	cli := client.NewDockerCli(nil, stdoutPipe, nil, testDaemonProto, testDaemonAddr, nil)
	go func (){
		fmt.Println("12")
		err:= cli.CmdRun("--name","deis-etcd","phife.atribecalledchris.com:5000/deis/etcd:0.3.0")
		if err != nil {
			t.Fatalf("runEtcdTest %s",err)
		}

	}( )
	go func() {
		fmt.Println("here")
		time.Sleep(5000 * time.Millisecond)
		if err := closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("runEtcdTest %s",err)
		}
	}()
	time.Sleep(1000 * time.Millisecond)
	for{
		if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
		fmt.Println(cmdBytes)
		}else{
			break
		}
		fmt.Println("Running Etcd ")
	}
	done<-true
}

func buildRegistryTest(t *testing.T){
	stdin, _   := io.Pipe()
	stdout, stdoutPipe := io.Pipe()
	cli := client.NewDockerCli(nil, stdoutPipe, nil, testDaemonProto, testDaemonAddr, nil)
	go func ( ){
		err:= cli.CmdBuild("../")
		if err != nil {
			t.Fatalf("buildRegistryTest %s",err)
		}
		if err = closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("buildRegistryTest %s",err)
		}
	}( )
	time.Sleep(3000 * time.Millisecond)
	for{
		if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
		fmt.Println(cmdBytes)
		}else{
			break
		}
		fmt.Println("building Deis registy Dockerfile")
	}
}

func runDeisRegistryDataTest(t *testing.T){
	stdin, _   := io.Pipe()
	stdout, stdoutPipe := io.Pipe()

	cli := client.NewDockerCli(nil, stdoutPipe, nil, testDaemonProto, testDaemonAddr, nil)

	go func ( ){
		err:= cli.CmdInspect("--format","'{{ .Config.Hostname }}'","deis-registry-data")
		/*if err != nil {
			t.Fatalf("runDeisRegistryDataTest %s",err)
		}*/
		if err = closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("runDeisRegistryDataTest %s",err)
		}
	}( )
	go func() {
		//fmt.Println("here1")
		time.Sleep(2000 * time.Millisecond)
		if err := closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("runEtcdTest %s",err)
		}
	}()
	var hostname string
	time.Sleep(1000 * time.Millisecond)
	for{
		if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
		fmt.Println(cmdBytes)
		hostname=cmdBytes
		}else{
			break
		}
		fmt.Println("inspecting deis registry data")
	}

	if strings.Contains(hostname, "Error") ==true {
		go func ( ){
			err:= cli.CmdRun("--name","deis-registry-data","-v","/data","deis/base","/bin/true")
			if err != nil {
				t.Fatalf("%s",err)
			}
			if err := closeWrap(stdout, stdoutPipe,stdin); err != nil {
				t.Fatalf("%s",err)
			}
		}( )
		for{
			if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
			fmt.Println(cmdBytes)
			}else{
				break
			}
			fmt.Println("pulling Deis registry data")
		}
	}
}


func runDeisRegistryTest(t *testing.T,IPAddress string){
	stdin, _   := io.Pipe()
	stdout, stdoutPipe := io.Pipe()
	cli := client.NewDockerCli(nil, stdoutPipe, nil, testDaemonProto, testDaemonAddr, nil)
	go func (){
		//docker run --name deis-registry -p 5000:5000 -e PUBLISH=5000 -e HOST=10.0.0.37 --volumes-from deis-registry-data deis/registry

		err:= cli.CmdRun("--name","deis-registry","-p","5000:5000","-e","PUBLISH=5000","-e","HOST="+IPAddress,"--volumes-from","deis-registry-data","deis/registry")
		if err != nil {
			t.Fatalf("runDeisRegistryTest %s",err)
		}
		if err := closeWrap(stdout, stdoutPipe,stdin); err != nil {
			t.Fatalf("runDeisRegistryTest %s",err)
		}
	}( )
	time.Sleep(3000 * time.Millisecond)
	for{
		if cmdBytes,err:= bufio.NewReader(stdout).ReadString('\n'); err==nil{
			if strings.Contains(cmdBytes, "Booting") ==true {
				if err := closeWrap(stdout, stdoutPipe,stdin); err != nil {
					t.Fatalf("runDeisRegistryTest %s",err)
				}
			}
		fmt.Println(cmdBytes)
		}else{
			break
		}
		fmt.Println("pulling Deis Registry")
	}

}




func TestBuild(t *testing.T) {
	done := make(chan bool, 1)
	done2 := make(chan bool,1)
	pullEtcdTest(t,done)
	fmt.Println("1st")
	go func() {
		fmt.Println("2nd")
		<-done
		fmt.Println("3rd")
		runEtcdTest(t,done2)
		fmt.Println("4th")
	}()
	<-done2
	fmt.Println("5th")
	buildRegistryTest(t)
	fmt.Println("6th")
	runDeisRegistryDataTest(t)
	fmt.Println("7th")
	IPAddress:=strings.TrimSuffix(getIPAdressTest(t), "\n")
	fmt.Println(IPAddress)
	fmt.Println("8th")
	runDeisRegistryTest(t,IPAddress)
}