package webutility

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

var mu = &sync.Mutex{}
var allPayloads []payloadBuff

type LangMap map[string]map[string]string

type Field struct {
	Parameter  string `json:"param"`
	Type       string `json:"type"`
	Visible    bool   `json:"visible"`
	Editable   bool   `json:"editable"`
}

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

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

type payloadBuff struct {
	Type         string             `json:"tableType"`
	Method	     string             `json:"method"`
	Params	     map[string]string  `json:"params"`
	Lang	     []Translation      `json:"lang"`
	Fields	     []Field            `json:"fields"`
	Correlations []CorrelationField `json:"correlationFields"`
	IdField      string             `json:"idField"`
	// Data can only hold slices of any type. It can't be used for itteration
	Data	     interface{}        `json:"data"`
}

type Payload struct {
	Method	     string             `json:"method"`
	Params	     map[string]string  `json:"params"`
	Lang	     []Translation      `json:"lang"`
	Fields	     []Field            `json:"fields"`
	Correlations []CorrelationField `json:"correlationFields"`
	IdField      string             `json:"idField"`

	// Data can only hold slices of any type. It can't be used for itteration
	Data	     interface{}        `json:"data"`
}

// NewPayload returs payload for provided table.
func NewPayload(r *http.Request, table string) Payload {
	var pload Payload

	pload.Method = r.Method + " " + r.URL.Path
	if table != "" {
		pload.Params = make(map[string]string, 0)
		pload.Lang = loadTranslations(table)
		pload.Fields = loadFields(table)
		pload.IdField = loadIdField(table)
		pload.Correlations = loadCorrelations(table)
	}
	return pload
}

// DeliverPayload writes payload to w.
func DeliverPayload(w http.ResponseWriter, payload Payload) {
	json.NewEncoder(w).Encode(payload)
	payload.Data = nil
}

// loadTranslations loads translations for a payload of the given data type.
func loadTranslations(id string) []Translation {
	translations := make([]Translation, 0)

	for _, pload := range allPayloads {
		if pload.Type == id {
			for _, t := range pload.Lang {
				//translations[t.Language] = t.FieldsLabels
				translations = append(translations, Translation{
					Language: t.Language,
					FieldsLabels: t.FieldsLabels,
				})
			}
		}
	}

	return translations
}

// loadFields loads fields for a payload of the given data type.
func loadFields(id string) []Field {
	fields := make([]Field, 0)

	for _, pload := range allPayloads {
		if pload.Type == id{
			for _, f := range pload.Fields {
				fields = append(fields, f)
			}
		}
	}

	return fields
}

// loadIdField loads ID field for a payload of the given data type.
func loadIdField(id string) string {
	for _, pload := range allPayloads {
		if pload.Type == id {
			return pload.IdField
		}
	}
	return ""
}

// loadCorrelations loads correlations field for a payload of the given data type.
func loadCorrelations(id string) []CorrelationField {
	resp := make([]CorrelationField, 0)

	for _, pload := range allPayloads {
		if pload.Type == id {
			for _, f := range pload.Correlations {
				resp = append(resp, f)
			}
		}
	}

	return resp
}

// InitTables loads all payloads in the memory.
func InitTables(db *ora.Ses, project string) error {
	jsonbuf, _ := fetchJSON(db, EqualQuotes(project))
	mu.Lock()
	defer mu.Unlock()
	json.Unmarshal(jsonbuf, &allPayloads)
	if len(allPayloads) == 0 {
		return errors.New("tables config is corrupt")
	}
	return nil
}

// fetchJSON fetches JSON configuration file from TABLES_CONFIG table.
func fetchJSON(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 {
			// Ignore for now, it's some weird streaming read/write LOB error.
			// TODO: Find a fix for this.
			//return nil, err
		}
	}

	return bytes, nil
}

// DecodeJSON decodes JSON data from r to v and returns any error
// that happens during decoding process.
func DecodeJSON(r io.Reader, v interface{}) error {
	return json.NewDecoder(r).Decode(v)
}