protocol_decoder.py

"""
Protocol Decoder Module
Supports multiple decoding formats: ASCII, HEX, JSON, and custom frame protocols.
"""

import json
import re
from datetime import datetime


class PacketDecoder:
    """Handles decoding of received data packets in various formats."""
    
    @staticmethod
    def decode_ascii(data):
        """Decode data as ASCII text."""
        try:
            return data.decode('ascii', errors='replace')
        except Exception as e:
            return f"<Decode Error: {str(e)}>"
            
    @staticmethod
    def decode_hex(data):
        """Decode data as hexadecimal."""
        return ' '.join(f'{b:02X}' for b in data)
        
    @staticmethod
    def decode_hex_compact(data):
        """Decode data as compact hexadecimal (no spaces)."""
        return ''.join(f'{b:02X}' for b in data)
        
    @staticmethod
    def decode_binary(data):
        """Decode data as binary."""
        return ' '.join(f'{b:08b}' for b in data)
        
    @staticmethod
    def decode_json(data):
        """Try to decode data as JSON."""
        try:
            text = data.decode('utf-8', errors='replace')
            parsed = json.loads(text)
            return json.dumps(parsed, indent=2)
        except Exception as e:
            return f"<Not valid JSON: {str(e)}>"
            
    @staticmethod
    def decode_mixed(data):
        """Decode as ASCII with hex for non-printable characters."""
        result = []
        for b in data:
            if 32 <= b <= 126:  # Printable ASCII
                result.append(chr(b))
            else:
                result.append(f'<{b:02X}>')
        return ''.join(result)


class CustomFrameDecoder:
    """Decoder for custom frame protocols with configurable delimiters."""
    
    def __init__(self, start_delimiter=b'\x02', end_delimiter=b'\x03', 
                 include_delimiters=True):
        self.start_delimiter = start_delimiter
        self.end_delimiter = end_delimiter
        self.include_delimiters = include_delimiters
        self.buffer = b''
        
    def feed_data(self, data):
        """Feed data to the decoder and extract complete frames."""
        self.buffer += data
        frames = []
        
        while True:
            # Find start delimiter
            start_idx = self.buffer.find(self.start_delimiter)
            if start_idx == -1:
                break
                
            # Find end delimiter after start
            end_idx = self.buffer.find(self.end_delimiter, start_idx + len(self.start_delimiter))
            if end_idx == -1:
                break
                
            # Extract frame
            if self.include_delimiters:
                frame = self.buffer[start_idx:end_idx + len(self.end_delimiter)]
            else:
                frame = self.buffer[start_idx + len(self.start_delimiter):end_idx]
                
            frames.append(frame)
            
            # Remove processed data from buffer
            self.buffer = self.buffer[end_idx + len(self.end_delimiter):]
            
        return frames
        
    def reset(self):
        """Clear the internal buffer."""
        self.buffer = b''


class ProtocolParser:
    """Parse protocol-specific data based on configurable rules."""
    
    def __init__(self, profile_name="default"):
        self.profile_name = profile_name
        self.rules = []
        
    def add_rule(self, name, pattern, description=""):
        """Add a parsing rule with regex pattern."""
        self.rules.append({
            'name': name,
            'pattern': re.compile(pattern),
            'description': description
        })
        
    def parse(self, data_str):
        """Parse data string against all rules."""
        matches = []
        for rule in self.rules:
            match = rule['pattern'].search(data_str)
            if match:
                matches.append({
                    'rule': rule['name'],
                    'match': match.group(0),
                    'groups': match.groups(),
                    'description': rule['description']
                })
        return matches


class DataPacket:
    """Represents a single data packet with metadata."""
    
    def __init__(self, raw_data, timestamp, port, direction='RX'):
        self.raw_data = raw_data
        self.timestamp = timestamp
        self.port = port
        self.direction = direction  # 'RX' for received, 'TX' for transmitted
        self.decoded_ascii = PacketDecoder.decode_ascii(raw_data)
        self.decoded_hex = PacketDecoder.decode_hex(raw_data)
        self.size = len(raw_data)
        
    def to_dict(self):
        """Convert packet to dictionary for export."""
        return {
            'timestamp': self.timestamp,
            'port': self.port,
            'direction': self.direction,
            'size': self.size,
            'raw_hex': self.decoded_hex,
            'ascii': self.decoded_ascii
        }