package restutility
  
  import (
  	"net/http"
  	"strings"

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

  )

  var allPayloads []Payload

  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 Payload 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"`
  }

  func NewPayload(r *http.Request, table string) Payload {
  	var pload Payload

  	pload.Method = strings.ToLower(r.Method + " " + r.URL.Path)
  	pload.Params = make(map[string]string, 0)
  	pload.Lang = loadTranslations(allPayloads, table)
  	pload.Fields = loadFields(allPayloads, table)
  	pload.IdField = loadIdField(allPayloads, table)
  	pload.Correlations = loadCorrelations(allPayloads, table)

  	return pload
  }

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

  }

  func loadTranslations(payloads []Payload, id string) []Translation {
  	translations := make([]Translation, 0)
  
  	for _, pload := range payloads {
  		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
  }
  
  func loadFields(payloads []Payload, id string) []Field {
  	fields := make([]Field, 0)
  
  	for _, pload := range payloads {
  		if pload.Type == id{
  			for _, f := range pload.Fields {
  				fields = append(fields, f)
  			}
  		}
  	}
  
  	return fields
  }
  
  func loadIdField(payloads []Payload, id string) string {
  	for _, pload := range payloads {
  		if pload.Type == id {
  			return pload.IdField
  		}
  	}
  	return ""
  }
  
  func loadCorrelations(payloads []Payload, id string) []CorrelationField {
  	resp := make([]CorrelationField, 0)
  
  	for _, pload := range payloads {
  		if pload.Type == id {
  			for _, f := range pload.Correlations {
  				resp = append(resp, f)
  			}
  		}
  	}
  
  	return resp
  }
  
  func InitTables(db *ora.Ses, project string) error {
  	jsonbuf, _ := fetchTablesConfig(db, EqualQuotes(project))
  	json.Unmarshal(jsonbuf, &allPayloads)
  	if len(allPayloads) == 0 {
  		return errors.New("tables config is corrupt")
  	}
  	fmt.Printf("broj ucitanih tabela: %d
  ", len(allPayloads))
  	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
  ", err)
  		}

  	}

  	return bytes, nil

  }