package restutility

import (
	"encoding/json"
	"errors"
	"gopkg.in/rana/ora.v3"
	"io"
	"io/ioutil"
	"fmt"
)

type TableConfig struct {
	Tables []Table
}

type Table struct {
	TableType    string             `json:"tableType"`
	Translations []TableTranslation `json:"translations"`
	TableFields  []Field            `json:"tableFields"`
	Correlations []CorrelationField `json:"correlationFields"`
	IdField      string             `json:"idField"`
}

type CorrelationField struct {
	Result   string   `json:"result"`
	Elements []string `json:"elements"`
	Type     string   `json:"type"`
}

type TableTranslation struct {
	Language     string            `json:"language"`
	FieldsLabels map[string]string `json:"fieldsLabels"`
}

func (tl TableConfig) LoadTranslations(tableType string) LangMap {
	translations := make(LangMap, 0)

	for _, table := range tl.Tables {
		if tableType == table.TableType {
			for _, t := range table.Translations {
				translations[t.Language] = t.FieldsLabels
			}
		}
	}

	return translations
}

func (tl TableConfig) LoadFields(tableType string) []Field {
	fields := make([]Field, 0)

	for _, table := range tl.Tables {
		if tableType == table.TableType {
			for _, f := range table.TableFields {
				fields = append(fields, f)
			}
		}
	}

	return fields
}

func (tl TableConfig) LoadIdField(tableType string) string {
	for _, table := range tl.Tables {
		if tableType == table.TableType {
			return table.IdField
		}
	}
	return ""
}

func (tl TableConfig) LoadCorrelations(tableType string) []CorrelationField {
	resp := make([]CorrelationField, 0)

	for _, table := range tl.Tables {
		if tableType == table.TableType {
			for _, f := range table.Correlations {
				resp = append(resp, f)
			}
		}
	}

	return resp
}

var _tables TableConfig
var _prevProject string

func InitTables(db *ora.Ses, project string) error {
	jsonbuf, _ := fetchTablesConfig(db, EqualQuotes(project))
	json.Unmarshal(jsonbuf, &_tables.Tables)
	if len(_tables.Tables) == 0 {
		return errors.New("tables config is corrupt")
	}
	return nil
}

func fetchTablesConfig(db *ora.Ses, project string) ([]byte, error) {
	stmt, err := db.Prep(`SELECT
		JSON_CLOB
		FROM TABLES_CONFIG
		WHERE PROJEKAT` + project, ora.S)
	defer stmt.Close()

	if err != nil {
		return nil, err
	}

	rset, err := stmt.Qry()
	if err != nil {
		return nil, err
	}

	bytes := make([]byte, 0)
	if rset.Next() {
		lob := rset.Row[0].(io.Reader)
		bytes, err = ioutil.ReadAll(lob)
		if err != nil {
			fmt.Printf("mega error: %v\n", err)
		}
	}

	return bytes, nil
}

func loadTable(table string) JSONParams {
	return NewJSONParams(_tables.LoadTranslations(table),
		_tables.LoadFields(table),
		_tables.LoadIdField(table),
		_tables.LoadCorrelations(table))
}