change project name, decouple main and parsing entrance

this will make it more like a library, where another project can create Parser struct and call ParseDemos to get all relevant information, and if anyone wants to use executable from this project, the main function works exactly the same

2 files changed, 151 insertions, 60 deletions

diff --git a/cmd/parser.go b/cmd/parser.go
index b4cbba4..f21d91f 100644
--- a/cmd/parser.go
+++ b/cmd/parser.go
@@ -1,53 +1,106 @@
 package main
 
 import (
+        "errors"
         "fmt"
         "os"
+        "strings"
 
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/packets"
-        "github.com/pektezol/demoparser/pkg/writer"
+        "github.com/pektezol/sdp.go/pkg/packets"
+        "github.com/pektezol/sdp.go/pkg/writer"
 )
 
+type Demo struct {
+        Headers  packets.Headers   `json:"headers"`
+        Messages []packets.Message `json:"messages"`
+}
+
+type Parser struct {
+        DemoPath string
+        writer   strings.Builder
+}
+
+func NewParser(demoPath string) *Parser {
+        return &Parser{
+                DemoPath: demoPath,
+        }
+}
+
 const littleEndian bool = true
 
 func main() {
         if len(os.Args) != 2 {
-                panic("specify file in command line arguments")
+                fmt.Println("specify file in command line arguments")
+                os.Exit(1)
         }
-        writer.AppendLine("Generated By: github.com/pektezol/demoparser")
-        files, err := os.ReadDir(os.Args[1])
-        if err != nil { // If it's not a directory
-                file, err := os.Open(os.Args[1])
-                if err != nil {
-                        panic(err)
-                }
-                writer.AppendLine("\nFile Name: %s", file.Name())
-                reader := bitreader.NewReader(file, littleEndian)
-                demoParserHandler(reader)
-                defer file.Close()
-                fmt.Println(writer.GetString())
-                return
+        parser := NewParser(os.Args[1])
+        _, err := parser.ParseDemos()
+        if err != nil {
+                fmt.Println(err.Error())
+                os.Exit(1)
         }
-        for _, fileinfo := range files { // If it is a directory
-                file, err := os.Open(os.Args[1] + fileinfo.Name())
+        fmt.Println(parser.GetOutput())
+}
+
+func (p *Parser) GetOutput() string {
+        return p.writer.String()
+}
+
+func (p *Parser) ParseDemos() ([]Demo, error) {
+        writer.AppendLine("Generated By: github.com/pektezol/sdp.go")
+        files, err := os.ReadDir(p.DemoPath)
+        if err != nil {
+                // not a directory
+                file, err := os.Open(p.DemoPath)
                 if err != nil {
-                        panic(err)
+                        return []Demo{}, err
                 }
-                writer.AppendLine("\nFile Name: %s", file.Name())
-                reader := bitreader.NewReader(file, littleEndian)
-                demoParserHandler(reader)
                 defer file.Close()
+                reader := bitreader.NewReader(file, littleEndian)
+                demo := demoParserHandler(reader, file.Name())
+                p.writer = writer.GetWriter()
+                return []Demo{demo}, nil
+        } else {
+                demos := []Demo{}
+                // directory
+                for _, fileinfo := range files {
+                        if len(fileinfo.Name()) > 4 && fileinfo.Name()[len(fileinfo.Name())-4:] == ".dem" {
+                                file, err := os.Open(p.DemoPath + fileinfo.Name())
+                                if err != nil {
+                                        return []Demo{}, err
+                                }
+                                defer file.Close()
+                                reader := bitreader.NewReader(file, littleEndian)
+                                demo := demoParserHandler(reader, file.Name())
+                                demos = append(demos, demo)
+                        }
+                }
+                p.writer = writer.GetWriter()
+                if len(demos) == 0 {
+                        return demos, errors.New("no demo found in given directory")
+                }
+                return demos, nil
         }
-        fmt.Println(writer.GetString())
 }
 
-func demoParserHandler(reader *bitreader.Reader) {
-        packets.ParseHeaders(reader)
+func demoParserHandler(reader *bitreader.Reader, filename string) Demo {
+        demo := Demo{}
+        writer.AppendLine("\nFile Name: %s", filename)
+        // this is for recovering after a panic inside parse headers and packet.
+        // this approach was taken since error handling bitreader functions would take a long time.
+        defer func() {
+                if err := recover(); err != nil {
+                        writer.AppendLine("failed to parse demo: %v", err)
+                }
+        }()
+        demo.Headers = packets.ParseHeaders(reader)
         for {
-                packet := packets.ParsePackets(reader)
-                if packet.PacketType == 7 {
+                message := packets.ParseMessage(reader)
+                demo.Messages = append(demo.Messages, message)
+                if message.PacketType == 7 {
                         break
                 }
         }
+        return demo
 }
diff --git a/pkg/packets/packets.go b/pkg/packets/packets.go
index b1d6a40..1bf3f57 100644
--- a/pkg/packets/packets.go
+++ b/pkg/packets/packets.go
@@ -2,63 +2,101 @@ package packets
 
 import (
         "github.com/pektezol/bitreader"
-        "github.com/pektezol/demoparser/pkg/classes"
-        "github.com/pektezol/demoparser/pkg/writer"
+        "github.com/pektezol/sdp.go/pkg/classes"
+        "github.com/pektezol/sdp.go/pkg/writer"
 )
 
-type PacketMessageInfo struct {
-        PacketType uint8
+type MessageType uint8
+
+const (
+        SignOn MessageType = iota + 1
+        Packet
+        SyncTick
+        ConsoleCmd
+        UserCmd
+        DataTables
+        Stop
+        CustomData
+        StringTables
+)
+
+type Message struct {
+        PacketType MessageType
         TickNumber int32
         SlotNumber uint8
+        Data       any
 }
 
-func ParsePackets(reader *bitreader.Reader) PacketMessageInfo {
-        packetType := reader.TryReadUInt8()
-        tickNumber := reader.TryReadSInt32()
-        slotNumber := reader.TryReadUInt8()
-        switch packetType {
-        case 1: // SignOn
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "SIGNON", packetType)
+func ParseMessage(reader *bitreader.Reader) Message {
+        message := Message{
+                PacketType: MessageType(reader.TryReadUInt8()),
+                TickNumber: reader.TryReadSInt32(),
+                SlotNumber: reader.TryReadUInt8(),
+        }
+        writer.AppendLine("[%d] %s (%d):", message.TickNumber, message.PacketType.String(), message.PacketType)
+        switch message.PacketType {
+        case SignOn:
                 signOn := classes.SignOn{}
                 signOn.ParseSignOn(reader)
-        case 2: // Packet
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "PACKET", packetType)
+                message.Data = signOn
+        case Packet:
                 packet := classes.Packet{}
                 packet.ParsePacket(reader)
-        case 3: // SyncTick
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "SYNCTICK", packetType)
+                message.Data = packet
+        case SyncTick:
                 syncTick := classes.SyncTick{}
                 syncTick.ParseSyncTick()
-        case 4: // ConsoleCmd
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "CONSOLECMD", packetType)
+                message.Data = syncTick
+        case ConsoleCmd:
                 consoleCmd := classes.ConsoleCmd{}
                 consoleCmd.ParseConsoleCmd(reader)
-        case 5: // UserCmd
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "USERCMD", packetType)
+                message.Data = consoleCmd
+        case UserCmd:
                 userCmd := classes.UserCmd{}
                 userCmd.ParseUserCmd(reader)
-        case 6: // DataTables
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "DATATABLES", packetType)
+                message.Data = userCmd
+        case DataTables:
                 dataTables := classes.DataTables{}
                 dataTables.ParseDataTables(reader)
-        case 7: // Stop
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "STOP", packetType)
+                message.Data = dataTables
+        case Stop:
                 stop := classes.Stop{}
                 stop.ParseStop(reader)
-        case 8: // CustomData TODO: not sar data
+                message.Data = stop
+        case CustomData: // TODO: not sar data
                 customData := classes.CustomData{}
-                customData.ParseCustomData(reader, tickNumber, packetType)
-        case 9: // StringTables TODO: parsing string table data
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "STRINGTABLES", packetType)
+                customData.ParseCustomData(reader, message.TickNumber, uint8(message.PacketType))
+                message.Data = customData
+        case StringTables: // TODO: parsing string table data
                 stringTables := classes.StringTables{}
                 stringTables.ParseStringTables(reader)
-        default: // Invalid
-                writer.AppendLine("[%d] %s (%d):", tickNumber, "INVALID", packetType)
+                message.Data = stringTables
+        default:
                 panic("invalid packet type")
         }
-        return PacketMessageInfo{
-                PacketType: packetType,
-                TickNumber: tickNumber,
-                SlotNumber: slotNumber,
+        return message
+}
+
+func (t MessageType) String() string {
+        switch t {
+        case SignOn:
+                return "SIGNON"
+        case Packet:
+                return "PACKET"
+        case SyncTick:
+                return "SYNCTICK"
+        case ConsoleCmd:
+                return "CONSOLECMD"
+        case UserCmd:
+                return "USERCMD"
+        case DataTables:
+                return "DATATABLES"
+        case Stop:
+                return "STOP"
+        case CustomData:
+                return "CUSTOMDATA"
+        case StringTables:
+                return "STRINGTABLES"
         }
+        return "INVALID"
 }