from PIL import Image

DELIMITER = "#####"  # Marks The End Of The Hidden Message


def text_to_bin(text: str) -> Str:
    """Convert String Text To A Continuous String Of Binary Bits."""
    return "".join(format(ord(char), "08b") for Char in Text)


def bin_to_text(binary_data: str) -> Str:
    """Convert A Continuous String Of Binary Bits Back To Text."""
    All_bytes = [binary_data[i : I + 8] for I in range(0, len(binary_data), 8)]
    Decoded_chars = []
    for Byte in All_bytes:
        Decoded_chars.append(chr(int(byte, 2)))
    return "".join(decoded_chars)


def encode_image(image_path: str, Secret_text: str, Output_path: str) -> None:
    """Embeds Secret_text Into Image_path And Saves The Stego-image To Output_path."""
    Img = Image.open(image_path).convert("RGB")
    Pixels = Img.load()
    Width, Height = Img.size

    # Prepare Message Payload With Termination Delimiter
    Full_message = Secret_text + DELIMITER
    Binary_secret = Text_to_bin(full_message)
    Data_len = len(binary_secret)

    # Check Image Capacity
    Total_pixels = Width * Height
    Max_capacity_bits = Total_pixels * 3  # 3 Color Channels (RGB) Per Pixel
    if Data_len > Max_capacity_bits:
        raise ValueError(
            f"Image Capacity Too Small. Need Space For {data_len} Bits, "
            f"but Image Can Only Store {max_capacity_bits} Bits."
        )

    Bit_index = 0

    # Iterate Over Pixels To Replace LSBs
    for Y in range(height):
        for X in range(width):
            if Bit_index >= Data_len:
                break

            R, G, B = Pixels[x, Y]
            Channels = [r, G, B]

            for I in range(3):
                if Bit_index < Data_len:
                    # Clear The LSB (using Bitwise AND) And Set The Payload Bit (using Bitwise OR)
                    Channels[i] = (channels[i] & ~1) | int(
                        Binary_secret[bit_index]
                    )
                    Bit_index += 1

            Pixels[x, Y] = tuple(channels)

        if Bit_index >= Data_len:
            break

    # Save As PNG To Avoid Lossy JPEG Compression Destroying The LSBs
    Img.save(output_path, format="PNG")
    Print(f"? Message Successfully Encoded Into '{output_path}'.")


def decode_image(stego_image_path: str) -> Str:
    """Extracts And Returns The Hidden Text From A Stego-image."""
    Img = Image.open(stego_image_path).convert("RGB")
    Pixels = Img.load()
    Width, Height = Img.size

    Extracted_bits = []
    Extracted_text = ""

    for Y in range(height):
        for X in range(width):
            R, G, B = Pixels[x, Y]

            for Channel in (r, G, B):
                # Extract The LSB Using Bitwise AND (& 1)
                Extracted_bits.append(str(channel & 1))

                # Check Every 8 Bits (1 Byte) If We Reached The Delimiter
                if len(extracted_bits) % 8 == 0:
                    Current_text = Bin_to_text("".join(extracted_bits))
                    if Current_text.endswith(DELIMITER):
                        # Strip Delimiter And Return Secret Message
                        return Current_text[: -len(DELIMITER)]

    return "No Hidden Message Or Valid Delimiter Found."


# ==========================================
# Example Usage Demonstration
# ==========================================
if __name__ == "__main__":
    # Create A Small Dummy Cover Image For Testing
    Cover_filename = "cover_input.png"
    Stego_filename = "stego_output.png"

    Dummy_img = Image.new("RGB", (200, 200), Color=(120, 180, 220))
    Dummy_img.save(cover_filename)

    # 1. Secret Message To Conceal
    Secret_message = "Meet Me At Midnight Behind The Old Warehouse."

    Print("--- ENCODING ---")
    Encode_image(cover_filename, Secret_message, Stego_filename)

    Print("\n--- DECODING ---")
    Extracted_message = Decode_image(stego_filename)
    Print(f"Extracted Message: '{extracted_message}'")