# ----------
# 1-Wire Timing Array Generator
#
# Generates a C array of timer compare values for 1-Wire protocol bit-banging
# ----------

def one_wire_bit_edges(byte, start_time, slot, low0, low1, event_counter, first_bit_low=True):
    """
    Generate (time, comment) pairs for each edge in a 1-Wire byte transmission.
    - For the very first bit after the presence pulse, the line is already LOW,
      so only the RISE (HIGH) is recorded.
    - For all other bits, both FALL (LOW) and RISE (HIGH) are recorded.
    """
    times = []
    t = start_time
    if first_bit_low:
        # First bit: line is already LOW, so only RISE (HIGH) after LOW duration
        bitval = (byte >> 0) & 1
        low = low1 if bitval else low0
        t_rise = t + low
        comment_rise = f"Bit 0: RISE (HIGH) after {low} µs LOW, sending '{bitval}'"
        times.append((t_rise, comment_rise))
        t += slot
        event_counter += 1
        bit_start = 1
    else:
        bit_start = 0
    for bit in range(bit_start, 8):
        bitval = (byte >> bit) & 1
        comment_fall = f"Bit {bit}: FALL (LOW) - sending '{bitval}'"
        times.append((t, comment_fall))
        low = low1 if bitval else low0
        t_rise = t + low
        comment_rise = f"Bit {bit}: RISE (HIGH) after {low} µs LOW"
        times.append((t_rise, comment_rise))
        t += slot
        event_counter += 2
    return times, event_counter

def generate_ccr_edges(
    reset_low=480,
    presence_high=500,
    command_bytes=None,
    start_time=0,
    slot=70,
    low0=60,
    low1=1
):
    """
    Generate the full sequence of (time, comment) pairs for a 1-Wire transaction.
    - Includes reset and presence pulses, and all command bytes.
    """
    if command_bytes is None:
        command_bytes = []
    times = []
    t = start_time
    event_counter = 0

    # -- 1. Reset Pulse (Master pulls line LOW) --
    t += reset_low
    comment_rise = "RESET: RISE (HIGH) - end reset, start presence pulse"
    times.append((t, comment_rise))
    event_counter += 1

    # -- 2. Presence Pulse (Slave pulls line LOW after presence_high) --
    t += presence_high
    comment_fall2 = f"PRESENCE: FALL (LOW) - end presence (width {presence_high} µs), line LOW for first bit"
    times.append((t, comment_fall2))
    event_counter += 1

    # -- 3. Command Bytes (LSB first) --
    for idx, b in enumerate(command_bytes):
        # Add empty line and command byte comment for readability
        times.append((None, ""))
        byte_comment = (f"// Command byte 0x{b:02X} "
                        f"(binary: {b:08b}, LSB first: {', '.join(str((b>>i)&1) for i in range(8))})")
        times.append((None, byte_comment))

        # For the very first command byte, the line is already LOW after presence
        first_bit_low = (idx == 0)
        bit_times, new_counter = one_wire_bit_edges(
            b, t, slot, low0, low1, event_counter, first_bit_low
        )
        times.extend(bit_times)
        event_counter = new_counter
        t += 8 * slot  # Move to the start time for the next byte

    return times

def format_c_array(name, times):
    """
    Format the (time, comment) pairs as a C array, with header comments
    inside the array definition, separated by blank lines for clarity.
    """
    out = f"const uint16_t {name}[] = {{\n"
    out += "\n"  # Blank line after array definition
    out += (
        "    // Timer starts with channel output state LOW\n"
        "    // Each value is a timer compare value for the next output edge\n"
        "    // Indices in brackets are sequential events in the waveform\n"
    )
    out += "\n"  # Blank line after header comments
    indent = "    "
    event_index = 0
    for item in times:
        if isinstance(item, tuple):
            t, comment = item
            if t is not None:
                out += f"{indent}{t}, // [{event_index}] {comment}\n"
                event_index += 1
            else:
                if comment == "":
                    out += "\n"
                else:
                    out += indent + comment + "\n"
        else:
            out += indent + str(item) + "\n"
    out += "};"
    return out

# ----------
# Example usage: Adjust the parameters below as needed for your application
# ----------
if __name__ == "__main__":
    # Slot time (total bit period), LOW durations for '0' and '1'
    slot = 70
    low0 = 60
    low1 = 1

    # Generate timing for reset, presence, and two command bytes (0xCC, 0x44)
    ccr_times = generate_ccr_edges(
        reset_low=480,         # Reset pulse duration (µs)
        presence_high=500,     # Presence pulse HIGH duration (µs) (wider than usual)
        command_bytes=[0xCC, 0x44],
        start_time=0,
        slot=slot,
        low0=low0,
        low1=low1
    )

    # Print the formatted C array
    print(format_c_array("ccr_seq", ccr_times))