package main

import (
	"flag"
	"fmt"
	"os"

	//"os"
	"encoding/binary"
	"encoding/hex"
	"os/exec"
)

const magicMicroseconds = 0xa1b2c3d4
const versionMajor = 2
const versionMinor = 4

func WriteEmptyPcap(filename string, timestamp int64, length int, data []byte) error {
	var cooked = [...]byte{0x00, 0x00, 0x03, 0x04, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00}

	var buf []byte
	//24+16+16 = 56
	buf = make([]byte, 56+length)
	binary.LittleEndian.PutUint32(buf[0:4], magicMicroseconds)
	binary.LittleEndian.PutUint16(buf[4:6], versionMajor)
	binary.LittleEndian.PutUint16(buf[6:8], versionMinor)
	// bytes 8:12 stay 0 (timezone = UTC)
	// bytes 12:16 stay 0 (sigfigs is always set to zero, according to
	//   http://wiki.wireshark.org/Development/LibpcapFileFormat
	binary.LittleEndian.PutUint32(buf[16:20], 0x00040000)
	binary.LittleEndian.PutUint32(buf[20:24], 0x00000071)

	// Packet Header
	binary.LittleEndian.PutUint64(buf[24:32], uint64(timestamp))

	binary.LittleEndian.PutUint32(buf[32:36], uint32(length+16))
	binary.LittleEndian.PutUint32(buf[36:40], uint32(length+16))

	copy(buf[40:], cooked[:])
	copy(buf[56:], data[:])

	err := os.WriteFile(filename, buf[:], 0644)
	//fmt.Printf("CAP: %v\n", buf)

	return err
}

// tshark -r gtp.pcap -T json -d tcp.port==8080,http2  -Y "http2"
func execTshark(html string, filename string, proto string, port int) {
	var tshark *exec.Cmd
	var sharkCmd string

	pcapPath := filename
	dataPort := fmt.Sprintf("tcp.port==%d,http2", port)
	if proto == "http2" {
		//tshark = exec.Command("tshark", "-r"+pcapPath,
		//                "-Y"+proto,
		//		"-d"+dataPort,
		//                "-T", "pdml")
		sharkCmd = fmt.Sprintf("tshark -r %s -T pdml -d tcp.port==%s,http2  -Y \"%s\" > %s.pdml", pcapPath, dataPort, proto, pcapPath)
		tshark = exec.Command("sh", "-c", sharkCmd)
	} else {
		//tshark = exec.Command("tshark", "-r"+pcapPath,
		//		"-Y"+proto,
		//		"-T", "pdml")
		sharkCmd = fmt.Sprintf("tshark -r %s -T pdml -Y \"%s\" > %s.pdml", pcapPath, proto, pcapPath)
		tshark = exec.Command("sh", "-c", sharkCmd)
	}
	_, err := tshark.CombinedOutput()
	if err != nil {
		fmt.Printf("tshark failed with %s\n", err)
	} else {
		//fmt.Printf("combined out:\n%s\n", string(out))
		pdmlFile := fmt.Sprintf("%s.pdml", filename)

		//err1 := os.WriteFile(pdmlFile, []byte(out), 0666)
		//if err1 != nil {
		//	fmt.Println("write html failed")
		//}else {
		//xsltproc pdml2html.xsl ngap.pdml > /home/omcuser/ngap.html
		command := fmt.Sprintf("xsltproc /usr/local/omc/etc/schema/pdml2html.xsl %s > %s", pdmlFile, html)
		dest := exec.Command("sh", "-c", command)
		_, err2 := dest.Output()
		if err2 != nil {
			fmt.Println("Error:", err2, command)
		}
		//}
	}
}

func ipDataHandle(html string, iftype string, port int, timestamp int64, data []byte) int {
	var filePath, proto string

	if iftype == "N2" || iftype == "N1" {
		filePath = fmt.Sprintf("/tmp/ng%d.pcap", timestamp)
		proto = "ngap"
	} else if iftype == "N4" {
		filePath = fmt.Sprintf("/tmp/pf%d.pcap", timestamp)
		proto = "pfcp"
	} else {
		filePath = fmt.Sprintf("/tmp/hp%d.pcap", timestamp)
		proto = "http2"
	}

	err := WriteEmptyPcap(filePath, timestamp, len(data), data)
	if err != nil {
		fmt.Printf("tshark failed with %s\n", err)

	} else {
		execTshark(html, filePath, proto, port)
	}
	return 0
}

func main() {
	var html, iftype, ipdata string
	var timestamp int64
	var port int

	flag.Int64Var(&timestamp, "t", 0, "timestamp")
	flag.StringVar(&iftype, "i", "", "interface type")
	flag.IntVar(&port, "p", 0, "data port")
	flag.StringVar(&ipdata, "d", "", "ip packet data")
	flag.StringVar(&html, "f", "", "html file path")

	flag.Parse()

	ds, err := hex.DecodeString(ipdata)

	if err != nil {
		return
	}
	ipDataHandle(html, iftype, port, timestamp, ds)

}