import time
import struct

# Constants
NETWORK_ID = 0x1234
ACK_TIMEOUT = 75  # ms
SEGMENT_SIZE = 24  # Max payload size for LoRa
SIMULATED_DELAY = 0.1  # Simulated over-the-air delay in seconds

# Simulated LoRa buffer to act as the communication channel
simulated_lora_buffer = []

# Transmitter Functions
def send_packet_emulated(packet):
    print(f"Transmitter: Sending packet - {packet}")
    simulated_lora_buffer.append(packet)

def receive_ack_emulated():
    if simulated_lora_buffer and simulated_lora_buffer[0] == b'ACK':
        simulated_lora_buffer.pop(0)  # Remove ACK from buffer
        print("Transmitter: ACK received.")
        return True
    return False

def compute_crc(data):
    crc = 0xFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            if crc & 0x0001:
                crc = (crc >> 1) ^ 0xA001
            else:
                crc >>= 1
    return struct.pack('>H', crc)

def send_segment(segment_number, data):
    crc = compute_crc(data)
    packet = struct.pack('B', segment_number) + data + crc
    send_packet_emulated(packet)

def wait_for_ack():
    start_time = time.ticks_ms()
    while time.ticks_diff(time.ticks_ms(), start_time) < ACK_TIMEOUT:
        if receive_ack_emulated():
            return True
        time.sleep(0.01)  # Small delay to avoid tight looping
    return False

def transfer_file():
    segment_number = 0
    data = b"Sample file content split into segments"  # Simulated file content
    for i in range(0, len(data), SEGMENT_SIZE):
        segment = data[i:i+SEGMENT_SIZE]
        send_segment(segment_number, segment)
        if wait_for_ack():
            print(f"Transmitter: Segment {segment_number} acknowledged.")
            segment_number += 1
        else:
            print(f"Transmitter: Segment {segment_number} not acknowledged, resending.")

# Receiver Functions
def read_packet_emulated():
    if simulated_lora_buffer and simulated_lora_buffer[0] != b'ACK':
        packet = simulated_lora_buffer.pop(0)
        print(f"Receiver: Received packet - {packet}")
        return packet
    return None

def send_ack_emulated():
    print("Receiver: Sending ACK.")
    simulated_lora_buffer.append(b'ACK')

def receive_segments():
    packet = read_packet_emulated()
    if packet:
        segment_number = packet[0]
        data = packet[1:-2]
        received_crc = struct.unpack('>H', packet[-2:])[0]
        computed_crc = struct.unpack('>H', compute_crc(data))[0]  # Calculate CRC for verification
        
        print(f"Receiver: Computed CRC: {computed_crc:#04x}, Received CRC: {received_crc:#04x}")
        
        if received_crc == computed_crc:
            print(f"Receiver: Segment {segment_number} received successfully.")
            send_ack_emulated()
        else:
            print(f"Receiver: CRC mismatch for segment {segment_number}.")

# Main simulation loop
def main_simulation():
    start_transmission = True
    while True:
        # Start the transmission process
        if start_transmission:
            transfer_file()
            start_transmission = False

        # Delay to simulate over-the-air delay
        time.sleep(SIMULATED_DELAY)

        # Receiver processes incoming data
        receive_segments()

        # Delay to give time for ACK to process
        time.sleep(SIMULATED_DELAY)

# Run the main simulation
main_simulation()