package models

import (
	"encoding/json"
	"io/ioutil"
	"time"

	"github.com/google/uuid"
	"github.com/sirupsen/logrus"
	"gitlab.dcso.lolcat/LABS/styx/utils"
)

// BuildNode builds a node to send to MQ instance.
func BuildNode(flag string, dataType string, data string) *Node {
	t := time.Now()
	rfc3339time := t.Format(time.RFC3339)
	return &Node{
		ID:       flag + "--" + uuid.New().String(),
		Type:     dataType,
		Data:     data,
		Created:  rfc3339time,
		Modified: rfc3339time,
	}
}

func WrapCertStreamData(data CertStreamStruct) *CertStreamWrapper {
	t := time.Now()
	rfc3339time := t.Format(time.RFC3339)
	return &CertStreamWrapper{
		ID:       "certstream--" + uuid.New().String(),
		Type:     "certstream_raw",
		Data:     data,
		Created:  rfc3339time,
		Modified: rfc3339time,
	}
}

// BuildEdge build a send from two nodes with a given source type.
func BuildEdge(source string, nodeOneUUID string, nodeTwoUUID string) *Edge {
	t := time.Now()
	rfc3339time := t.Format(time.RFC3339)
	return &Edge{
		ID:        uuid.New().String(),
		Source:    source,
		NodeOneID: nodeOneUUID,
		NodeTwoID: nodeTwoUUID,
		Timestamp: rfc3339time,
	}
}

func SavePaste(filename string, data *PasteWrapper) {
	err := utils.FileExists(filename)
	if err != nil {
		logrus.Error(err)
	}

	pasteFile, err := ioutil.ReadFile(filename)
	if err != nil {
		logrus.Error(err)
	}
	rawPaste := []PasteWrapper{}

	if err := json.Unmarshal(pasteFile, &rawPaste); err != nil {
		logrus.Error(err)
	}

	rawPaste = append(rawPaste, *data)

	rawBytes, err := json.Marshal(rawPaste)
	if err != nil {
		logrus.Error(err)
	}

	err = ioutil.WriteFile(filename, rawBytes, 0644)
	if err != nil {
		logrus.Error(err)
	}
}

func SaveRaw(filename string, data *CertStreamWrapper) {
	err := utils.FileExists(filename)
	if err != nil {
		logrus.Error(err)
	}
	nodeFile, err := ioutil.ReadFile(filename)
	if err != nil {
		logrus.Error(err)
	}
	rawDatas := []CertStreamWrapper{}

	if err := json.Unmarshal(nodeFile, &rawDatas); err != nil {
		logrus.Error(err)
	}

	rawDatas = append(rawDatas, *data)

	rawBytes, err := json.Marshal(rawDatas)
	if err != nil {
		logrus.Error(err)
	}

	err = ioutil.WriteFile(filename, rawBytes, 0644)
	if err != nil {
		logrus.Error(err)
	}
}

// SaveNode saves a node to a file.
func SaveNode(filename string, node *Node) {
	err := utils.FileExists(filename)
	if err != nil {
		logrus.Error(err)
	}
	nodeFile, err := ioutil.ReadFile(filename)
	if err != nil {
		logrus.Error(err)
	}
	nodeDatas := []Node{}

	if err := json.Unmarshal(nodeFile, &nodeDatas); err != nil {
		logrus.Error(err)
	}

	nodeDatas = append(nodeDatas, *node)

	nodeBytes, err := json.Marshal(nodeDatas)
	if err != nil {
		logrus.Error(err)
	}

	err = ioutil.WriteFile(filename, nodeBytes, 0644)
	if err != nil {
		logrus.Error(err)
	}
}

// SaveEdge saves an edge to a file.
func SaveEdge(edge *Edge) {
	err := utils.FileExists("edges.json")
	if err != nil {
		logrus.Error(err)
	}

	edgeFile, err := ioutil.ReadFile("edges.json")
	if err != nil {
		logrus.Error(err)
	}
	edgeDatas := []Edge{}

	if err := json.Unmarshal(edgeFile, &edgeDatas); err != nil {
		logrus.Error(err)
	}

	edgeDatas = append(edgeDatas, *edge)
	edgeBytes, err := json.Marshal(edgeDatas)
	if err != nil {
		logrus.Error(err)
	}

	err = ioutil.WriteFile("edges.json", edgeBytes, 0644)
	if err != nil {
		logrus.Error(err)
	}
}