#!/usr/bin/env python3
"""
Identification Overlay Node:
- Creates an OCR region in data_collector with a blue overlay.
- Detects instances of a specified word and draws adjustable overlays.
- Users can configure offset, margin, polling frequency, and select OCR engine.
"""

import re
from OdenGraphQt import BaseNode
from PyQt5.QtCore import QTimer
from Modules import data_collector


class IdentificationOverlayNode(BaseNode):
    __identifier__ = "bunny-lab.io.identification_overlay_node"
    NODE_NAME = "Identification Overlay"

    def __init__(self):
        super(IdentificationOverlayNode, self).__init__()

        # User-configurable options
        self.add_text_input("search_term", "Search Term", text="Aibatt")
        self.add_text_input("offset_value", "Offset Value (X,Y)", text="0,0")  # X,Y Offset
        self.add_text_input("margin", "Margin", text="5")  # Box Margin
        self.add_text_input("polling_freq", "Polling Frequency (ms)", text="500")  # Polling Rate
        self.add_combo_menu("ocr_engine", "Type", items=["CPU", "GPU"])
        self.set_property("ocr_engine", "CPU")  # Set default value after adding the menu

        self.region_id = "identification_overlay"
        data_collector.create_ocr_region(self.region_id, x=250, y=50, w=300, h=200, color=(0, 0, 255))

        data_collector.start_collector()
        self.set_name("Identification Overlay")

        # Timer for updating overlays
        self.timer = QTimer()
        self.timer.timeout.connect(self.update_overlay)

        # Set initial polling frequency
        self.update_polling_frequency()

    def update_polling_frequency(self):
        """
        Reads the user-defined polling frequency and updates the timer interval.
        """
        polling_text = self.get_property("polling_freq")
        try:
            polling_interval = max(50, int(polling_text))  # Minimum 50ms for near real-time
        except ValueError:
            polling_interval = 500  # Default to 500ms

        self.timer.start(polling_interval)

    def update_overlay(self):
        """
        Updates the overlay with detected word positions.
        """
        search_term = self.get_property("search_term")
        offset_text = self.get_property("offset_value")
        margin_text = self.get_property("margin")
        ocr_engine = self.get_property("ocr_engine")

        # Read and apply polling frequency updates
        self.update_polling_frequency()

        # Parse user-defined offset
        try:
            offset_x, offset_y = map(int, offset_text.split(","))
        except ValueError:
            offset_x, offset_y = 0, 0  # Default to no offset if invalid input

        # Parse user-defined margin
        try:
            margin = int(margin_text)
        except ValueError:
            margin = 5  # Default margin if invalid input

        if not search_term:
            return

        # Get detected word positions using the selected OCR engine
        detected_positions = data_collector.find_word_positions(
            self.region_id, search_term, offset_x, offset_y, margin, ocr_engine
        )

        # Draw detected word boxes
        data_collector.draw_identification_boxes(self.region_id, detected_positions, color=(0, 0, 255))