package framework

import (
	"log"
	"reflect"
	"testing"
)

// {{{ contract

const DummyProviderName = "container:test"

type IDummyService interface {
	GetDummy() DummyStruct
}

type DummyStruct struct {
	Name string
}

// }}}
// {{{ provider
type DummyServiceProvider struct{}

func (p *DummyServiceProvider) Name() string {
	return DummyProviderName
}

func (p *DummyServiceProvider) Register(c Container) NewInstance {
	return NewDummyService
}

func (p *DummyServiceProvider) Init(c Container) error {
	log.Println("init")
	return nil
}

func (p *DummyServiceProvider) InstantiateLater() bool {
	return true
}

func (p *DummyServiceProvider) Params(c Container) []interface{} {
	return []interface{}{c}
}

// }}}
// {{{ service

type DummyService struct {
	IDummyService

	// parameters
	c Container
}

func (d *DummyService) GetDummy() DummyStruct {
	return DummyStruct{
		Name: "Dummy!",
	}
}

func NewDummyService(params ...interface{}) (interface{}, error) {
	c := params[0].(Container)

	log.Println("new dummy service")

	return &DummyService{c: c}, nil
}

// }}}

func TestBind(t *testing.T) {
	container := NewGoWebContainer()
	provider := &DummyServiceProvider{}

	container.Bind(provider)

	dummyService := container.MustMake(DummyProviderName).(IDummyService)

	want := DummyStruct{
		Name: "Dummy!",
	}
	got := dummyService.GetDummy()

	if !reflect.DeepEqual(want, got) {
		t.Errorf("want %v, got %v ", want, got)
	}
}