Wand

from requests import post
import threading
import asyncio
from bleak import BleakClient, BleakError
import struct
import json
import time


# Define the device address and characteristics UUIDs
DEVICE_ADDRESS = "00:11:22:FF:EE:DD"

UUID_SUBSCRIBE_CHARACTERISTIC = "83d79d92-d99b-45f3-86f3-246dafbae585"
UUID_STROKE_CHARACTERISTIC = "26410220-1fb0-41f5-8a33-1042783047fa"

STROKE_POINT_COUNT = 160

# Variables to store the values of the characteristics
spell = None

spellList = ['Arresto Momentum', 'Ascendo', 'Bedroom', 'Descendo', 'Livingroom', 'Lumos', 'Nox', 'Revelio', 'Silenco', "Totus Obscurum"]


spellChain = []
startedThreads = []

# Stroke Collector Class
class StrokeCollector:
    def __init__(self):
        self.strokes = []
        self.previous_state = 0
        self.filename = "gestures.json"
        self.sensor = {
            'data': {},
            'structure': [],
            'rendered': False
        }
        
    def process_ble_data(self, data):
        try:
            if len(data) != 328:
                print("Invalid data length")
                return

            # Unpack state (Int32) and length (Int32) from first 8 bytes
            state, length = struct.unpack('<ii', data[:8])
            
            # Validate stroke length (max 160 points = (328-8)/2)
            max_points = 160
            if length < 0 or length > max_points:
                print(f"Invalid stroke length: {length}")
                return

            # Extract stroke data starting after header (8 bytes)
            stroke_start = 8
            stroke_end = stroke_start + (length * 2)
            stroke_data = data[stroke_start:stroke_end]
            
            # Process points from the correct offset
            points = []
            for ptr in range(0, len(stroke_data), 2):
                # Read signed 8-bit values (-128 to 127)
                x = struct.unpack_from('<b', stroke_data, ptr)[0] / 128.0
                y = struct.unpack_from('<b', stroke_data, ptr + 1)[0] / 128.0
                points.append({'x': x, 'y': y})

            # Handle stroke completion (state 2 = ended)
            if state == 2 and self.previous_state != 2:
                self.strokes.append({
                    "index": len(self.strokes),
                    "strokePoints": points,
                    "label": ""
                })
                self.save_to_file()
                print(f"Saved stroke {len(self.strokes)} with {len(points)} points")
                
            self.previous_state = state
        except struct.error as se:
            print(f"Unpack error: {str(se)}")
        except Exception as e:
            print(f"Processing error: {str(e)}")

    def save_to_file(self):
        try:
            with open(self.filename, 'w') as f:
                json.dump({"strokes": self.strokes}, f, indent=2)
        except Exception as e:
            print(f"Save error: {str(e)}")

# Function to handle notifications from the subscribed characteristic
async def notification_handler(sender, data, client):
    global spell
    
    # spellChar is an unsigned char (1 byte), so we unpack the first byte
    spellNumber = struct.unpack('B', data)[0]
    spell = spellList[spellNumber]
    take_spell_action(spell)
    print(f"Notification received from {sender}: {spell}")
    print(spellChain)
    

async def monitor_strokes(client, collector):
    try:
        stroke_char = client.services.get_characteristic(UUID_STROKE_CHARACTERISTIC)
        while client.is_connected:
            data = await client.read_gatt_char(stroke_char)
            collector.process_ble_data(data)
            await asyncio.sleep(0.2)
    except Exception as e:
        print(f"Stroke monitoring error: {str(e)}")

# Function to connect, read the characteristics, and subscribe to notifications
async def connect_and_subscribe():
    global spell
    collector = StrokeCollector()
    
    error = False
    while True:
        try:
            async with BleakClient(DEVICE_ADDRESS) as client:
                print(f"Connected to {DEVICE_ADDRESS}")

                # Subscribe to notifications from the specified characteristic
                await client.start_notify(UUID_SUBSCRIBE_CHARACTERISTIC, lambda sender, data: asyncio.create_task(notification_handler(sender, data, client)))
                
                asyncio.create_task(monitor_strokes(client, collector))
                
                error = False

                # Keep the connection alive and handle reconnections if disconnected
                while True:
                    if not client.is_connected:
                        print("Connection lost. Reconnecting...")
                        break
                    await asyncio.sleep(1)  # Check the connection status periodically

        except BleakError as e:
            if not error:
                print(f"Connection error: {e}")
                error = True
        except Exception as e:
            print(f"Unexpected error: {e}")

        # Wait a moment before trying to reconnect
        await asyncio.sleep(5)

# Main entry point to start the BLE connection loop
async def main():
    await connect_and_subscribe()




class Room:
  def __init__(self, name, devices):
    self.name = name
    self.devices = devices


class Device:
  def __init__(self, name, dType):
    self.name = name
    self.dType = dType
    self.commands = populate_commands(dType)


class LocationSpell:
  def __init__(self, location, time):
    self.location = location
    self.time = time


def populate_commands(dType):
    if dType == "Light":
      return ["TurnOff", "TurnOn", "TurnUp", "TurnDown", "Halt"]
    elif dType == "Curtain":
      return ["Close", "Open", "Halt"]
    elif dType == "TV":
      return ["TurnOff", "TurnOn", "VolumeUp", "VolumeDown", "Mute", "Pause"]


rooms = [
  Room("Bedroom", [
    Device("MainLight", "Light"),
    Device("Television", "TV"),
    Device("BlackoutCurtain", "Curtain")
  ]),
  Room("LivingRoom", [
    Device("MainLight", "Light"),
    #Device("SecondaryLight", "Light"),
    Device("Television", "TV"),
  ]),
  Room("Office", [
    Device("MainLight", "Light")
  ])
]

dividingDistance = 100
multiplier = 4
locationSpellLockTime = 300
lastLocationSpell = LocationSpell(rooms[1], time.time() - 3600)

currentDistance = 100
lastSpellTime = time.time()




stop_threads = False
previousLocation = rooms[0]


def guess_at_location():
  #return rooms[2]
  timeSinceLocationSpell = time.time() - lastLocationSpell.time
  if timeSinceLocationSpell < locationSpellLockTime: #location spell cast in the last 5 minutes
    return lastLocationSpell.location
  certaintyBasedOnDistance = currentDistance - dividingDistance #possitive is one room, negative is another
  dist = abs(certaintyBasedOnDistance)
  if (dist > 6000 / timeSinceLocationSpell): #if the distance justifies prioritizing it over the last lock
    if certaintyBasedOnDistance > 0:
      return rooms[0]
    else:
      return rooms[1]
  else:
    return lastLocationSpell.location

url = "http://localhost:8123/api/events/"
headers = {
  "Authorization": "Bearer 
  #todo insert your unique code here
  ",
  "content-type": "application/json",
}

def trigger_event(eventName, payload={}):
  post(url + eventName, headers=headers, data=payload)
  print(url + eventName)

def take_spell_action(spell):
  global stop_threads
  global lastSpellTime
  global startedThreads
  global previousLocation
  if time.time() - lastSpellTime > 120:
    spellChain.clear()
  lastSpellTime = time.time()
  
  
  if spell == "Bedroom":
    lastLocationSpell.time = time.time()
    lastLocationSpell.location = rooms[0]
    previousLocation = rooms[0]
    spellChain.clear()
    trigger_event(
          "Bedroom" + "RoomSelected"
        )
  elif spell == "Livingroom":
    lastLocationSpell.time = time.time()
    lastLocationSpell.location = rooms[1]
    previousLocation = rooms[1]
    spellChain.clear()
    trigger_event(
          "LivingRoom" + "RoomSelected"
        )
  elif spell == "Office":
    lastLocationSpell.time = time.time()
    lastLocationSpell.location = rooms[2]
    previousLocation = rooms[2]
    spellChain.clear()
  elif spell == "Lumos":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "Light":
        trigger_event(
          location.name + device.name + device.commands[1]
        )
  elif spell == "Nox":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "Light":
        trigger_event(
          location.name + device.name + device.commands[0]
        )
  elif spell == "Ascendo":
    if "Lumos" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "Light":
          trigger_event(
              previousLocation.name + device.name + device.commands[2]
            )
    if "Muffilato" in spellChain or "Silenco" in spellChain or "Patronus" in spellChain or "Revelio" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "TV":
          trigger_event(
              previousLocation.name + device.name + device.commands[2]
            )


    if "Muffilato" in spellChain or "Silenco" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "TV":
          trigger_event(
              previousLocation.name + device.name + device.commands[2]
            )

  elif spell == "Descendo":
    if "Lumos" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "Light":
          trigger_event(
              previousLocation.name + device.name + device.commands[3]
            )

    if "Muffilato" in spellChain or "Silenco" in spellChain or "Patronus" in spellChain or "Revelio" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "TV":
          trigger_event(
              previousLocation.name + device.name + device.commands[3]
            )

  elif spell == "Arresto Momentum":
    if "Diffindo" in spellChain or "Colorpotus" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "Curtain":
          trigger_event(
            previousLocation.name + device.name + device.commands[2]
          )
    if "Lumos" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "Light":
          trigger_event(
            previousLocation.name + device.name + device.commands[4]
          )
    if "Revelio" in spellChain or "Patronus" in spellChain:
      for device in previousLocation.devices:
        if device.dType == "TV":
          trigger_event(
            previousLocation.name + device.name + device.commands[5]
          )

  elif spell == "Muffilato":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location

  elif spell == "Silenco":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "TV":
        trigger_event(
          location.name + device.name + device.commands[4]
        )

  elif spell == "Patronus" or spell == "Revelio":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "TV":
        trigger_event(
          location.name + device.name + device.commands[1]
        )
  elif spell == "Disillusionment":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "TV":
        trigger_event(
          location.name + device.name + device.commands[0]
        )
  elif spell == "Diffindo":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "Curtain":
        trigger_event(
          location.name + device.name + device.commands[1]
        )
  elif spell == "Colorpotus":
    spellChain.clear()
    spellChain.append(spell)
    location = guess_at_location()
    previousLocation = location
    for device in location.devices:
      if device.dType == "Curtain":
        trigger_event(
          location.name + device.name + device.commands[0]
        )
  elif spell == "Obscuro":
    take_spell_action("Disillusionment")
    take_spell_action("Colorpotus")
  elif spell == "Totus Obscurum":
    take_spell_action("Disillusionment")
    take_spell_action("Nox")
    take_spell_action("Colorpotus")
  elif spell == "":
    pass






if __name__ == "__main__":
    asyncio.run(main())



#take_spell_action("Office")
#time.sleep(2)
#take_spell_action("Nox")
#time.sleep(2)
#take_spell_action("Lumos")
#time.sleep(2)
#take_spell_action("Descendo")
#time.sleep(8)
#take_spell_action("Arresto Momentum")

#print(spellChain)
#trigger_event("OfficeMainLightTurnOn")

import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import matplotlib.pyplot as plt
import json
import os
import glob
import datetime


class StatsWindow(tk.Toplevel):
    def __init__(self, parent):
        super().__init__(parent)
        self.title("Data Statistics")
        self.geometry("800x600")

        # Configure main container
        self.main_frame = ttk.Frame(self)
        self.main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        # Directory selection
        self.dir_frame = ttk.Frame(self.main_frame)
        self.dir_frame.pack(fill=tk.X, pady=5)

        self.select_dir_btn = ttk.Button(
            self.dir_frame,
            text="Select Directory",
            command=self.load_directory
        )
        self.select_dir_btn.pack(side=tk.LEFT, padx=5)

        self.dir_label = ttk.Label(self.dir_frame, text="No directory selected")
        self.dir_label.pack(side=tk.LEFT, padx=5)

        # Plot area
        self.plot_frame = ttk.Frame(self.main_frame)
        self.plot_frame.pack(fill=tk.BOTH, expand=True, pady=10)

        # Information panel
        self.info_frame = ttk.Frame(self.main_frame)
        self.info_frame.pack(fill=tk.X, pady=10)

        self.stats_label = ttk.Label(
            self.info_frame,
            text="Select a directory to analyze data distribution",
            wraplength=700
        )
        self.stats_label.pack()

        # Initialize plot
        self.fig, self.ax = plt.subplots(figsize=(8, 4))
        self.canvas = FigureCanvasTkAgg(self.fig, master=self.plot_frame)
        self.canvas.get_tk_widget().pack(fill=tk.BOTH, expand=True)

    def load_directory(self):
        directory = filedialog.askdirectory()
        if not directory:
            return

        self.current_directory = directory
        self.dir_label.config(text=directory)
        self.analyze_data()

    def analyze_data(self):
        valid_labels = [
            "Arresto Momentum", "Ascendo", "Bedroom", "Descendo",
            "Livingroom", "Lumos", "Nox", "Revelio", "Silenco", "Totus Obscurum"
        ]
        counts = {label: 0 for label in valid_labels}
        file_count = 0

        # Process files
        for filename in os.listdir(self.current_directory):
            if filename.startswith("disapproved") or not filename.endswith(".json"):
                continue

            filepath = os.path.join(self.current_directory, filename)
            try:
                with open(filepath, 'r') as f:
                    data = json.load(f)
                    file_count += 1
                    for stroke in data.get("strokes", []):
                        label = stroke.get("label", "")
                        if label in counts:
                            counts[label] += 1
            except Exception as e:
                print(f"Error processing {filename}: {e}")

        # Calculate balance requirements
        max_count = max(counts.values()) if any(counts.values()) else 0
        balance_info = []
        for label in valid_labels:
            needed = max_count - counts[label]
            if needed > 0:
                balance_info.append(f"-{needed} {label}")

        # Update visualization
        self.ax.clear()
        if file_count == 0:
            self.ax.text(0.5, 0.5, 'No valid data found',
                         ha='center', va='center', fontsize=12)
            self.stats_label.config(text="No valid JSON files found in directory")
        else:
            bars = self.ax.bar(counts.keys(), counts.values())
            self.ax.set_title(f"Label Distribution ({file_count} files analyzed)")
            self.ax.set_ylabel("Count")
            self.ax.tick_params(axis='x', rotation=45)

            # Add value labels
            for bar in bars:
                height = bar.get_height()
                self.ax.annotate(f'{height}',
                                 xy=(bar.get_x() + bar.get_width() / 2, height),
                                 xytext=(0, 3),
                                 textcoords="offset points",
                                 ha='center', va='bottom')

            # Update balance information
            stats_text = "Additional needed to balance:\n" + "\n".join(balance_info)
            if not balance_info:
                stats_text = "All labels are balanced!"
            self.stats_label.config(text=stats_text)

        self.fig.tight_layout()
        self.canvas.draw()


class FileReviewApp:
    def __init__(self, root, directory):
        self.root = root
        self.directory = directory

        # Get the first file in the directory
        files = glob.glob(os.path.join(self.directory, "*.json"))
        if not files:
            raise FileNotFoundError("No JSON files found in the specified directory.")

        self.filepath = files[0]
        self.approved_lines = []
        self.disapproved_lines = []
        self.labeled_approved = {}
        self.labeled_disapproved = {}
        self.current_label = None
        self.current_index = 0

        # Load lines from JSON file
        with open(self.filepath, 'r') as file:
            self.data = json.load(file)
            self.lines = self.data.get("strokes", [])

        # GUI Elements
        self.button_frame = ttk.Frame(root)
        self.button_frame.pack(side=tk.TOP, fill=tk.X, padx=10, pady=5)

        labels = [
            "Arresto Momentum", "Ascendo", "Bedroom", "Descendo",
            "Livingroom", "Lumos", "Nox", "Revelio", "Silenco", "Totus Obscurum"
        ]

        for label in labels:
            btn = ttk.Button(self.button_frame, text=label,
                             command=lambda l=label: self.set_label(l))
            btn.pack(side=tk.LEFT, padx=2)

        none_btn = ttk.Button(self.button_frame, text="None",
                              command=lambda: self.set_label(None))
        none_btn.pack(side=tk.LEFT, padx=2)

        self.current_label_var = tk.StringVar()
        self.current_label_var.set("Current Label: None")
        status_label = ttk.Label(self.button_frame, textvariable=self.current_label_var)
        status_label.pack(side=tk.RIGHT, padx=10)

        self.canvas_frame = ttk.Frame(root)
        self.canvas_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)

        self.file_label = ttk.Label(
            root,
            text=f"Reviewing: {os.path.basename(self.filepath)}",
            font=("Arial", 12)
        )
        self.file_label.pack()

        # Control buttons
        self.control_frame = ttk.Frame(root)
        self.control_frame.pack(fill=tk.X, padx=10, pady=5)

        self.approve_button = ttk.Button(
            self.control_frame,
            text="Approve (1)",
            command=self.approve_line
        )
        self.approve_button.pack(side=tk.LEFT, padx=5)

        self.disapprove_button = ttk.Button(
            self.control_frame,
            text="Disapprove (3)",
            command=self.disapprove_line
        )
        self.disapprove_button.pack(side=tk.RIGHT, padx=5)

        self.back_button = ttk.Button(
            self.control_frame,
            text="Back (7)",
            command=self.go_back,
            state=tk.DISABLED
        )
        self.back_button.pack(side=tk.LEFT, padx=5)

        # Bottom buttons
        self.bottom_frame = ttk.Frame(root)
        self.bottom_frame.pack(fill=tk.X, padx=10, pady=10)

        self.export_button = ttk.Button(
            self.bottom_frame,
            text="Export",
            command=self.export_files,
            state=tk.DISABLED
        )
        self.export_button.pack(side=tk.RIGHT, padx=5)

        self.stats_btn = ttk.Button(
            self.bottom_frame,
            text="Show Statistics",
            command=self.show_stats
        )
        self.stats_btn.pack(side=tk.LEFT, padx=5)

        # Key bindings
        root.bind("1", lambda event: self.approve_line())
        root.bind("3", lambda event: self.disapprove_line())
        root.bind("7", lambda event: self.go_back())

        self.show_line()

    def set_label(self, label):
        self.current_label = label
        self.current_label_var.set(f"Current Label: {label if label else 'None'}")

    def plot_stroke(self, stroke):
        x_array = [coords["x"] for coords in stroke["strokePoints"]]
        y_array = [coords["y"] for coords in stroke["strokePoints"]]

        fig = plt.figure(figsize=(8, 4))
        ax = fig.add_subplot(111)
        ax.set_xlabel('x')
        ax.set_ylabel('y')
        ax.set_xlim(-0.6, 0.6)
        ax.set_ylim(-0.6, 0.6)
        ax.plot(x_array, y_array)

        return fig

    def show_line(self):
        if self.current_index < len(self.lines):
            line = self.lines[self.current_index]

            # Clear the canvas frame
            for widget in self.canvas_frame.winfo_children():
                widget.destroy()

            # Plot the stroke
            fig = self.plot_stroke(line)
            canvas = FigureCanvasTkAgg(fig, master=self.canvas_frame)
            canvas_widget = canvas.get_tk_widget()
            canvas_widget.pack(fill=tk.BOTH, expand=True)
            canvas.draw()

            # Update button states
            self.back_button.config(state=tk.NORMAL if self.current_index > 0 else tk.DISABLED)
        else:
            for widget in self.canvas_frame.winfo_children():
                widget.destroy()

            ttk.Label(self.canvas_frame, text="Review Complete!", font=("Arial", 16)).pack()
            self.export_button.config(state=tk.NORMAL)

    def approve_line(self):
        if self.current_index < len(self.lines):
            line = self.lines[self.current_index]
            if self.current_label:
                self.labeled_approved.setdefault(self.current_label, []).append(line)
            else:
                self.approved_lines.append(line)
            self.current_index += 1
            self.show_line()

    def disapprove_line(self):
        if self.current_index < len(self.lines):
            line = self.lines[self.current_index]
            if self.current_label:
                self.labeled_disapproved.setdefault(self.current_label, []).append(line)
            else:
                self.disapproved_lines.append(line)
            self.current_index += 1
            self.show_line()

    def go_back(self):
        if self.current_index > 0:
            self.current_index -= 1
            line = self.lines[self.current_index]

            # Remove from approved/disapproved lists
            removed = False
            for lst in [self.approved_lines, self.disapproved_lines]:
                if line in lst:
                    lst.remove(line)
                    removed = True
                    break

            if not removed:
                for d in [self.labeled_approved, self.labeled_disapproved]:
                    for label in list(d.keys()):
                        if line in d[label]:
                            d[label].remove(line)
                            if not d[label]:
                                del d[label]
                            removed = True
                            break
                    if removed:
                        break

            self.show_line()

    def export_files(self):
        current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        approved_filename = f"approved_{current_time}.json"
        disapproved_filename = f"disapproved_{current_time}.json"

        # Prepare approved data
        all_approved = []
        for label, strokes in self.labeled_approved.items():
            for stroke in strokes:
                stroke_copy = stroke.copy()
                stroke_copy["label"] = label
                all_approved.append(stroke_copy)
        all_approved.extend([s.copy() for s in self.approved_lines])

        # Prepare disapproved data
        all_disapproved = []
        for label, strokes in self.labeled_disapproved.items():
            for stroke in strokes:
                stroke_copy = stroke.copy()
                stroke_copy["label"] = label
                all_disapproved.append(stroke_copy)
        all_disapproved.extend([s.copy() for s in self.disapproved_lines])

        # Save files
        try:
            with open(os.path.join(self.directory + "/Checked/", approved_filename), 'w') as f:
                json.dump({"strokes": all_approved}, f)

            with open(os.path.join(self.directory + "/Checked/", disapproved_filename), 'w') as f:
                json.dump({"strokes": all_disapproved}, f)

            os.remove(self.filepath)
            messagebox.showinfo(
                "Export Complete",
                f"Files exported successfully:\n{approved_filename}\n{disapproved_filename}"
            )
        except Exception as e:
            messagebox.showerror("Export Error", f"Failed to export files: {str(e)}")

    def show_stats(self):
        StatsWindow(self.root)


if __name__ == "__main__":
    directory = "C:/Users..."  # Update this path as needed
    root = tk.Tk()
    root.title("Spell Review Tool")
    root.geometry("1000x800")

    # Style configuration
    style = ttk.Style()
    style.configure("TButton", padding=6)
    style.configure("TLabel", padding=4)

    app = FileReviewApp(root, directory)
    root.mainloop()