package sixteen

import (
	"fmt"
	"testing"
)

type K uint8

type Field interface {
	K() K
	String() string
}

type FieldIndex int

type FieldsMap map[FieldIndex][]Field

type Atype uint32

const (
	AA = Atype(12)
)

type Data struct {
	A      Atype
	Fields FieldsMap
}

func NewData(a Atype) Data {
	return Data{a, make(FieldsMap)}
}

func newDatas(fieldName string, field Field) []Data {
	data := NewData(AA)
	data.Add(fieldName, field)
	return []Data{data}
}

func (this *Data) Add(name string, field Field) {
	key := FieldIndex(0)
	kind := K(0)
	switch name {
	case "S123456":
		key = FieldIndex(1)
		kind = K(1)
	case "I123456789012":
		key = FieldIndex(2)
		kind = K(2)
	case "D12345678901":
		key = FieldIndex(3)
		kind = K(3)
	case "F12345678":
		key = FieldIndex(4)
		kind = K(4)
	default:
		panic("not valid fieldname " + name)
	}
	_ = kind
	this.Fields[key] = append(this.Fields[key], field)
}

func newSDatas(fieldName string, fields ...Field) []Data {
	data := NewData(AA)
	ss, err := NewStringsData(fields...)
	if err != nil {
		panic(err)
	}
	data.Add(fieldName, ss)
	return []Data{data}
}

type StringsData struct {
	Fields []Field
}

func NewStringsData(fields ...Field) (*StringsData, error) {
	return &StringsData{fields}, nil
}

func (this *StringsData) K() K {
	return K(9)
}

func (this *StringsData) String() string {
	return fmt.Sprintf("(%T) datas = %v", this, this.Fields)
}

type StringC struct {
	Value string
	B     bool
	N     int
}

func (this *StringC) K() K {
	return K(6)
}

func (this *StringC) String() string {
	return fmt.Sprintf("(%T)%v -B=%v -n=%v", this, this.Value, this.B, this.N)
}

type U struct {
	n, x uint64
}

func (this *U) K() K {
	return K(3)
}

func (this *U) String() string {
	return fmt.Sprintf("(%T)[%v, %v]", this, this.n, this.x)
}

func addDatas0(datas []Data, fieldName string, fields ...Field) []Data {
	for i := range fields {
		datas[0].Add(fieldName, fields[i])
	}
	return datas
}

var (
	d      = `d12345 1234567891 aa 2123456789`
	start  = `f123 s123453.I1234567890 ` + d + ` w1234 `
	cstart = `f123 s123453.I1234567890 ` + d + `w2435 `
)

func TestSixteen(t *testing.T) {
	m1 := `S123456 h12 s1234567 "bla"`
	p1 := newSDatas("S123456", &StringC{"bla", false, -1})
	m2 := `D12345678901 h12 s1234567 "alb"`
	mf2 := `D12345678901 h12 s1234567 "bla"`
	p2 := newSDatas("D12345678901", &StringC{"alb", false, -1})
	m3 := `I123456789012 h12 v1234 3`
	p3 := newDatas("I123456789012", &U{3, 3})
	m4 := `I123456789012 h12 v1234 4`
	p4 := newDatas("I123456789012", &U{4, 4})
	mf3 := `F12345678 h12 v1234 3`
	mf4 := `F12345678 h12 v1234 4`
	p11 := addDatas0(newSDatas("S123456", &StringC{"bla", false, -1}), "S123456", &StringsData{[]Field{&StringC{"bla", false, -1}}})
	p14 := addDatas0(newSDatas("S123456", &StringC{"bla", false, -1}), "I123456789012", &U{4, 4})
	p31 := addDatas0(newDatas("I123456789012", &U{3, 3}), "S123456", &StringsData{[]Field{&StringC{"bla", false, -1}}})
	p41 := addDatas0(newDatas("I123456789012", &U{4, 4}), "S123456", &StringsData{[]Field{&StringC{"bla", false, -1}}})
	p32 := addDatas0(newDatas("I123456789012", &U{3, 3}), "D12345678901", &StringsData{[]Field{&StringC{"alb", false, -1}}})
	p42 := addDatas0(newDatas("I123456789012", &U{4, 4}), "D12345678901", &StringsData{[]Field{&StringC{"alb", false, -1}}})
	p33 := addDatas0(newDatas("I123456789012", &U{3, 3}), "I123456789012", &U{3, 3})
	p34 := addDatas0(newDatas("I123456789012", &U{3, 3}), "I123456789012", &U{4, 4})
	p3f4 := addDatas0(newDatas("I123456789012", &U{3, 3}), "F12345678", &U{4, 4})
	pf34 := addDatas0(newDatas("F12345678", &U{3, 3}), "I123456789012", &U{4, 4})
	pf3f4 := addDatas0(newDatas("F12345678", &U{3, 3}), "F12345678", &U{4, 4})
	p2f2 := addDatas0(newSDatas("D12345678901", &StringC{"alb", false, -1}), "D12345678901", &StringsData{[]Field{&StringC{"bla", false, -1}}})
	p313 := addDatas0(newDatas("I123456789012", &U{3, 3}), "S123456", &StringsData{[]Field{&StringC{"bla", false, -1}}})
	p313 = addDatas0(p313, "I123456789012", &U{3, 3})
	p323 := addDatas0(newDatas("I123456789012", &U{3, 3}), "D12345678901", &StringsData{[]Field{&StringC{"alb", false, -1}}})
	p323 = addDatas0(p323, "I123456789012", &U{3, 3})
	p413 := addDatas0(newDatas("I123456789012", &U{4, 4}), "S123456", &StringsData{[]Field{&StringC{"bla", false, -1}}})
	p413 = addDatas0(p413, "I123456789012", &U{3, 3})
	p423 := addDatas0(newDatas("I123456789012", &U{4, 4}), "D12345678901", &StringsData{[]Field{&StringC{"alb", false, -1}}})
	p423 = addDatas0(p423, "I123456789012", &U{3, 3})
	_ = p11
	_ = p14
	_ = p31
	_ = p41
	_ = p32
	_ = p42
	_ = p33
	_ = p34
	_ = p3f4
	_ = pf34
	_ = pf3f4
	_ = p2f2
	_ = p313
	_ = p323
	_ = p413
	_ = p423
	_ = m1
	_ = p1
	_ = m2
	_ = mf2
	_ = p2
	_ = m3
	_ = p3
	_ = m4
	_ = p4
	_ = mf3
	_ = mf4
	q := map[string][]Data{
		start + m1: p1,
		start + m2: p2,
		start + m3: p3,
		start + m4: p4,
		fmt.Sprintf("%v(%v | %v)", start, m1, m2):                                                                         append(p1, p2...),
		fmt.Sprintf("%v(%v | %v) & (%v | %v)", start, m3, m4, m1, m2):                                                     append(p31, append(p32, append(p41, p42...)...)...),
		fmt.Sprintf("%v %v & %v", start, m3, m3):                                                                          p33,
		fmt.Sprintf("%v (%v | %v) & (%v | %v) & %v", start, m3, m4, m1, m2, m3):                                           append(p313, append(p323, append(p413, p423...)...)...),
		fmt.Sprintf("%v (%v | %v) & (%v | %v) & %v", cstart, m3, m4, m1, m2, m3):                                          append(p313, append(p323, append(p413, p423...)...)...),
		fmt.Sprintf("%v ((%v & %v) | (%v & %v) | (%v & %v) | (%v & %v)) & %v", start, m3, m1, m3, m2, m4, m1, m4, m2, m3): append(p313, append(p323, append(p413, p423...)...)...),
		fmt.Sprintf("%v (%v | %v) & (%v | %v)", start, m3, m1, m4, m1):                                                    append(p34, append(p31, append(p14, p11...)...)...),
		fmt.Sprintf("%v (%v | %v) & (%v | %v)", start, m3, mf3, m4, mf4):                                                  append(p34, append(p3f4, append(pf34, pf3f4...)...)...),
		fmt.Sprintf("%v (%v | %v) & (%v | %v)", start, m3, m4, m1, m1):                                                    append(p31, append(p31, append(p41, p41...)...)...),
		fmt.Sprintf("%v (%v & %v) | (%v & %v)", start, m3, m1, m4, m1):                                                    append(p31, p41...),
		fmt.Sprintf("%v ((%v) & (%v))", start, m2, mf2):                                                                   p2f2,
	}
	_ = q
}