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