package routebuildermdl

import (
	"encoding/json"
	"strconv"
	"strings"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/dalmdl/dao"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"

	"gopkg.in/mgo.v2/bson"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/dalmdl/mongodb"

	"github.com/tidwall/gjson"
)

// Master - struct for master Service
type Master struct {
	ServiceName  string
	IsCach       bool
	IsRestricted bool
	IsRoleBased  bool
	IsMongo      bool
	// MongoQuery
	// FDBQuery
}

// MongoQuery - for mongo service
type MongoQuery struct {
	Collection string
	Host       string
	Query      string
	Args       []string
}

// FDBQuery - for fdb services
type FDBQuery struct {
	FilePath string
	Query    []string
}

// Runable - helps to run
type Runable struct {
	Master
	MongoQuery
	FDBQuery
}

// MongoService - return mongo query object
func (m *Master) MongoService(host, collection, query string) *Runable {
	mongo := MongoQuery{
		Host:       host,
		Collection: collection,
		Query:      query,
	}
	m.IsMongo = true
	runable := &Runable{
		Master:     *m,
		MongoQuery: mongo,
	}
	return runable
}

// FDBService - return mongo query object
func (m *Master) FDBService(filPath string, query ...string) *Runable {
	FDB := FDBQuery{
		FilePath: filPath,
		Query:    query,
	}
	runable := &Runable{
		Master:   *m,
		FDBQuery: FDB,
	}
	return runable
}

// IsCachable for both fdb and mongo
func (m *Master) IsCachable(status bool) *Master {
	m.IsCach = status
	return m
}

// SetArgs set argument for query string
func (m *Runable) SetArgs(args ...string) *Runable {
	if m.Master.IsMongo {
		m.MongoQuery.Args = args
	}
	return m
}

// Register - register it in cacahe
func (m *Runable) Register() {
	service := ServiceCache{
		MasterService:   m,
		IsMasterService: true,
	}
	commonServiceRegistration(m.Master.ServiceName, service, m.Master.IsRestricted, m.Master.IsRestricted)
}

// Run - execute and return output and error
func (m *Runable) Run(data []byte) (interface{}, error) {
	if m.Master.IsMongo {
		return m.runMongoService(data)
	}
	return m.runFDBService()
}

func (m *Runable) runMongoService(data []byte) (interface{}, error) {
	rs := gjson.ParseBytes(data)
	for i, arg := range m.MongoQuery.Args {
		result := rs.Get(arg).String()
		argNotation := "~" + strconv.Itoa(i+1)
		m.MongoQuery.Query = strings.Replace(m.MongoQuery.Query, argNotation, result, 1)
	}

	var v map[string]interface{}
	unmarshalError := json.Unmarshal([]byte(m.MongoQuery.Query), &v)
	if errormdl.CheckErr(unmarshalError) != nil {
		loggermdl.LogError(unmarshalError)
		return nil, errormdl.CheckErr(unmarshalError)
	}
	query, getError := mongodb.GetMongoDAO(m.MongoQuery.Host, m.MongoQuery.Collection).GetData(v)
	if errormdl.CheckErr(getError) != nil {
		loggermdl.LogError(getError)
		return nil, errormdl.CheckErr(getError)
	}
	result := []bson.M{}
	parseError := query.All(&result)
	if errormdl.CheckErr(parseError) != nil {
		loggermdl.LogError(parseError)
		return nil, errormdl.CheckErr(parseError)
	}
	return result, nil
}

func (m *Runable) runFDBService() (interface{}, error) {
	rs, getError := dalmdl.GetDAO().
		FilePath(m.FDBQuery.FilePath).
		Query(m.FDBQuery.Query...).
		IsCacheable(m.Master.IsCach).
		Run()
	if errormdl.CheckErr(getError) != nil {
		loggermdl.LogError(getError)
		return nil, errormdl.CheckErr(getError)
	}
	return rs.Value(), nil
}