package orm

import (
	"fmt"
	"math/rand"
	"reflect"
	"strings"
	"sync"
	"time"
)

type tbl struct {
	rt     reflect.Type
	rv     reflect.Value
	lock   *sync.RWMutex
	name   string
	tFn    MapperFn
	fFn    MapperFn
	f      fields
	rel    relations
	mapped bool
}

func (t *tbl) GetName() string {
	t.ReadLock()
	defer t.Unlock()
	return t.getName()
}

func (t *tbl) getName() string {
	return t.getType().Name()
}

func (t *tbl) GetTableName() string {
	t.ReadLock()
	defer t.Unlock()
	return t.getTable()
}

func (t *tbl) getTable() string {
	if len(t.name) == 0 {
		t.name = t.tFn(t.getType().Name())
	}
	return t.name
}

func (t *tbl) String() string {
	return fmt.Sprintf("%s (`%s`):%s",
		t.getName(), t.getTable(),
		func() string {
			s := strings.Split(t.f.String(), ",")
			if len(s) <= 1 {
				return " " + t.f.String()
			}

			return "\n\t" + strings.Join(s, ",\n\t")
		}(),
	)
}

func (t *tbl) add(r reflect.StructField) {
	switch r.Type.Kind() {
	case reflect.Ptr:
		fmt.Println("Ptr", r)
	case reflect.Map:
		fmt.Println("Map", r)
	case reflect.Struct:
		fmt.Println("Struct", r)
	default:
		t.f = append(t.f, field{r.Name, t.fFn(r.Name), r.Type.Kind()})
	}
}

func (t *tbl) getType() reflect.Type {
	return t.rt
}

func (t *tbl) getValue() reflect.Value {
	return t.rv
}

func (t *tbl) isMapped() bool {
	return t.mapped
}

func (t *tbl) ReadLock() *tbl {
	t.lock.RLock()
	return t
}

func (t *tbl) WriteLock() *tbl {
	if t.mapped {
		return nil
	}
	t.lock.Lock()
	return t
}

func (t *tbl) Unlock() {
	if !t.mapped {
		t.mapped = true
		t.lock.Unlock()
		return
	}
	t.lock.RUnlock()
}

func (t *tbl) randomWork(wg *sync.WaitGroup) *tbl {
	time.Sleep((time.Duration)(rand.Intn(100)*rand.Intn(100)) * time.Millisecond)
	return t
}