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,
	}
}

// BuildCertNode builds a custom node based on CertStream.
func BuildCertNode(rawNode *CertStreamWrapper) *CertNode {
	return &CertNode{
		Fingerprint:      rawNode.Data.Data.LeafCert.Fingerprint,
		NotBefore:        time.Unix(int64(rawNode.Data.Data.LeafCert.NotBefore), 0).Format(time.RFC3339),
		NotAfter:         time.Unix(int64(rawNode.Data.Data.LeafCert.NotAfter), 0).Format(time.RFC3339),
		CN:               rawNode.Data.Data.LeafCert.Subject.CN,
		SourceName:       rawNode.Data.Data.Source.Name,
		BasicConstraints: rawNode.Data.Data.LeafCert.Extensions.BasicConstrains,
		RawUUID:          rawNode.ID,
	}
}

// CertNode represents our custom struct of data extraction from CertStream.
type CertNode struct {
	ID               string `json:"id"`
	Fingerprint      string `json:"fingerprint"`
	NotBefore        string `json:"notBefore"`
	NotAfter         string `json:"notAfter"`
	CN               string `json:"cn"`
	SourceName       string `json:"sourceName"`
	SerialNumber     string `json:"serialNumber"`
	BasicConstraints string `json:"basicConstraints"`
	RawUUID          string `json:"rawUUID"`
}

// WrapCertStreamData is a wrapper around CertStreamStruct.
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,
	}
}

// SavePaste saves a object received from PasteBin.
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)
	}
}

// SaveRaw save the raw CertStream data.
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)
	}
}

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

	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)
	}
}

// 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)
	}
}