constraints improve

package main

import (
	"errors"
	"strings"
)

type ConstraintsCalculator struct {
	Ops            []Op
	SlotId         string
	Offer          *Offer
	OfferAllocator map[string]*Offer
}

type Offer struct {
	OfferId   string
	AgentName string
	Ip        string
}

func New(slotId string, offerAllocator map[string]*Offer) *ConstraintsCalculator {
	return ConstraintsCalculator{
		Ops: make(0, Op),
	}
}

func (cc *ConstraintsCalculator) Parse(statement string) error {
	//cc.Ops =

	for _, o := range cc.Ops {
		o.Cc = cc
	}

	for _, o := range cc.Ops {
		if !o.Validate() {
			return errors.New("")
		}
	}

	return nil
}

func (cc *ConstraintsCalculator) TestMatch(offer *Offer) bool {
	for _, op := range cc.Ops {
		if !op.Eval() {
			return false
		}
	}

	return true
}

type Op interface {
	Eval() bool
	Validate() bool
}

type AndOp struct {
	Cc *ConstraintsCalculator

	LeftValue  interface{}
	RightValue interface{}
}

func (ao *AndOp) Eval() bool {
	lop, _ := LeftValue.(Op)
	rop, _ := RightValue.(Op)

	return lop.Eval() && rop.Eval()
}

func (ao *AndOp) Validate() bool {
	_, lok := LeftValue.(Op)
	_, rok := RightValue.(Op)

	return lok && rok
}

type OrOp struct {
	Cc *ConstraintsCalculator

	LeftValue  interface{}
	RightValue interface{}
}

func (ao *AndOp) Eval() bool {
	lop, _ := LeftValue.(Op)
	rop, _ := RightValue.(Op)

	return lop.Eval() || rop.Eval()
}

func (ao *AndOp) Validate() bool {
	_, lok := LeftValue.(Op)
	_, rok := RightValue.(Op)

	return lok && rok
}

type LikeOp struct {
	Cc *ConstraintsCalculator

	LeftValue  interface{}
	RightValue interface{}
}

func (ao *AndOp) Eval() bool {
	lop, _ := LeftValue.(string)
	rop, _ := RightValue.(string)

	switch strings.ToLower(lop) {
	case "hostname":
		ao.cc.Hostname()
	case "ip":
	default:
	}

	return false
}

func (ao *AndOp) Validate() bool {
	_, lok := LeftValue.(string)
	_, rok := RightValue.(string)

	return lok && rok
}

type UniqueOp struct {
	Cc *ConstraintsCalculator

	LeftValue  interface{}
	RightValue interface{}
}

func (ao *AndOp) Eval() bool {

	// easy
	return false
}

func (ao *AndOp) Validate() bool {
	_, lok := LeftValue.(string)

	return lok
}

type ContainsOp struct {
}

type IncludeOp struct {
}

func main() {
}