type Factory interface {
	CreateProduct() Product
}

type Product interface {
	Describe()
}

//具体的产品
type ConcreteProduct struct {
	Name string
}

func (conproduct *ConcreteProduct) Describe() {
	fmt.Println(conproduct.Name)
}

//具体工厂
type ConCreteFactory struct {}

func (confactory *ConCreteFactory) CreateProduct() Product {
	return &ConcreteProduct{Name: "KG"}
}

type Wheel int
type Vehicle struct {
	Wheels	  Wheel
	Seats 	  int
	Structure string
}

//builder interface
type Builder interface {
	SetWheels()		Builder
	SetSeats()		Builder
	SetStructure()  Builder
	GetVehicle()	Vehicle
}

//Director
type Director struct {
	builder Builder
}

func (director *Director) Construct() {
	director.builder.SetWheels().SetSeats().SetStructure()  //链式调用
}

func (director *Director) SetBuilder(builder Builder) {
	director.builder = builder
}

//car struct
type Car struct {
	vehicle Vehicle
}

func (car *Car) SetWheels() Builder {
	car.vehicle.Wheels = 4
	return car
}
func (car *Car) SetSeats() Builder {
	car.vehicle.Seats = 4
	return car
}
func (car *Car) SetStructure() Builder {
	car.vehicle.Structure = "Car"
	return car
}
func (car *Car) GetVehicle() Vehicle {
	return car.vehicle
}

type Car interface {
	Drive()
}
type BMW struct{}

func (b *BMW) Drive() {
	fmt.Println("Drive BMW")
}

type Audi struct{}

func (a *Audi) Drive() {
	fmt.Println("Drive Auti")
}
func Factory(name string) Car {
	switch strings.ToLower(name) {
	case "audi":
		return &Audi{}
	case "bmw":
		return &BMW{}
	default:
		fmt.Printf("Not Support %s\n", name)
		return nil
	}
}

type Payment interface {
	Pay(money int64) error
	Refund(money int64) error
}

type Alipay struct {
}

func (a *Alipay) Pay(money int64) (err error) {
	fmt.Printf("Pay by Alipay %d", money)
	return
}

func (a *Alipay) Refund(money int64) (err error) {
	fmt.Printf("Refund by Alipay %d", money)
	return
}

type WechatPay struct {
}

func (w *WechatPay) Pay(money int64) (err error) {
	fmt.Printf("Pay by WechatPay %d", money)
	return
}

func (w *WechatPay) Refund(money int64) (err error) {
	fmt.Printf("Refund by WechatPay %d", money)
	return
}
type BankPay struct {
}

func (w *BankPay) Pay(money int64) (err error) {
	fmt.Printf("Pay by BankPay %d", money)
	return
}

func (w *BankPay) Refund(money int64) (err error) {
	fmt.Printf("Refund by BankPay %d", money)
	return
}

type PayType struct {
	use Payment
}

func (u *PayType) SetPayment(payment Payment) {
	u.use = payment
}

func (u *PayType) Pay() error {
	return u.use.Pay(10)
}

func (u *PayType) Refund() error {
	return u.use.Refund(10)
}

func TestStrategy(t *testing.T) {
	a := assert.New(t)
 	p := PayType{}

	p.SetPayment(&Alipay{})
	a.Equal("Pay by Alipay 10",  p.Pay())
	a.Equal("Refund by Alipay 10",  p.Pay())
}

type Operator interface {
	SetA(int)
	SetB(int)
	Result() int
}

type OperatorFactory interface {
	Create() Operator
}

type OperatorBase struct {
	a, b int
}

//SetA 设置 A
func (o *OperatorBase) SetA(a int) {
	o.a = a
}

//SetB 设置 B
func (o *OperatorBase) SetB(b int) {
	o.b = b
}
type PlusOperator struct {
	*OperatorBase
}


type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Create() Operator {
	return &PlusOperator{
		OperatorBase: &OperatorBase{},
	}
}

func (o PlusOperator) Result() int {
	return o.a + o.b
}
type MinusOperator struct {
	*OperatorBase
}

type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Create() Operator {
	return &MinusOperator{
		OperatorBase: &OperatorBase{},
	}
}

func (o MinusOperator) Result() int {
	return o.a - o.b
}