package orm

import (
	"reflect"
)

type Model struct {
	Name               string
	Type               reflect.Type
	Relationships      map[string]*Relationship
	IDField            string
	Fields             map[string]*Field
	FieldsByColumnName map[string]*Field
	TableName          string
	embeddedIsh        bool
}

func (m *Model) addField(field *Field) {
	field.Model = m
	m.Fields[field.Name] = field
	m.FieldsByColumnName[field.ColumnName] = field
}

const (
	documentField = "Document"
	createdField  = "Created"
	modifiedField = "Modified"
)

func (m *Model) docField() *Field {
	return m.Fields[documentField]
}

func (m *Model) idField() *Field {
	return m.Fields[m.IDField]
}

func (m *Model) getPrimaryKey(val reflect.Value) (string, any) {
	colField := m.Fields[m.IDField]
	if colField == nil {
		return "", nil
	}
	colName := colField.ColumnName
	wasPtr := false
	if val.Kind() == reflect.Ptr {
		if val.IsNil() {
			return "", nil
		}
		val = val.Elem()
		wasPtr = true
	}
	if val.IsZero() && wasPtr {
		return "", nil
	}
	idField := val.FieldByName(m.IDField)
	if idField.IsValid() {
		return colName, idField.Interface()
	}
	return "", nil
}

func (m *Model) needsPrimaryKey(val reflect.Value) bool {
	_, pk := m.getPrimaryKey(val)
	return pk == nil || reflect.ValueOf(pk).IsZero()
}

func (m *Model) columnsWith(rel *Relationship) (cols []string, err error) {
	for _, f := range m.Fields {
		if f.ColumnType != "" {
			cols = append(cols, f.ColumnName)
		}
	}
	for _, r2 := range m.Relationships {
		if r2.Type == ManyToOne {
			cols = append(cols, pascalToSnakeCase(r2.joinField()))
		}
	}
	return
}