import io
import tkinter as tk
from tkinter import Frame, Canvas, ttk, PhotoImage

from PIL import ImageChops

from ..config import DISPLAY_TYPES, DISPLAY_MODES
from .draw_utils import draw_clock
from . import NumberView, CircleView, TimerView

from .button_interface import ButtonInterface
from .buttons_manager import ButtonsManager

from .recipes import RecipeSelection, RecipeManager, EditRecipe, Recipe

class MainView(tk.Frame, ButtonInterface):
    def __init__(self, parent,
                 tare_command=None,
                 calibrate_command=None,
                 **kwargs):
        super().__init__(parent, **kwargs)
        self.views = []
        self.timer_view = None  # Timer view is always active
        self.tare_command = tare_command
        self.calibrate_command = calibrate_command
        
        self.actions = Frame(self)
        self.actions.pack()
        self.calibrate_button = ttk.Button(self.actions, text="Calibrate", command=calibrate_command)
        self.calibrate_button.pack()

        self.im_size = (168, 144)
        self.center = (168 // 2, 144 // 2)

        # Create timer view that's always active
        self.canvas = Canvas(self, width=168, height=144, background='white',
                             highlightthickness=1, highlightbackground="black")
        self.canvas.pack()


        self.timer_view = TimerView(self.actions, self.im_size, self.center)
        self.buttons = ButtonsManager(self, self.im_size, self.center,
                                      curr_view=self)
        self.recipes_manager = RecipeManager()
        
        self.curr_mode = DISPLAY_MODES.MAIN
    
    def has_button(self):
        return True, True, True, True

    def left_press(self):
        self.timer_view.toggle_timer()
    
    def left_long_press(self):
        self.timer_view.reset_timer()
    
    def right_press(self):
        self.tare_command()
    
    def right_long_press(self):
        self.enter_recipe_selection()


    def render_left_press(self, draw, x, y):
        draw_clock(draw, (x, y), radius=3)

    def render_left_long_press(self, draw, x, y):
        draw_clock(draw, (x, y), radius=3)
        draw.text((x + 6, y - 5), "0.0", fill='black')

    def render_right_press(self, draw, x, y):
        draw.text((x, y), "T", fill='black')

    def render_right_long_press(self, draw, x, y):
        draw.text((x, y - 5), "R", fill='black')


    def enter_main_mode(self):
        self.curr_mode = DISPLAY_MODES.MAIN
        self.buttons.current_view = self
        self.refresh(0.0)

    def enter_recipe_selection(self):
        self.curr_mode = DISPLAY_MODES.RECIPE_SELECTION
        self.buttons.current_view = RecipeSelection(self,
                                                    self.im_size, self.center,
                                                    recipe_manager=self.recipes_manager,
                                                    edit_recipe_command=self.enter_edit_recipe,
                                                    deactivate_command=self.enter_main_mode)
        self.refresh(0.0)
    
    def enter_edit_recipe(self, recipe: Recipe = None):
        self.curr_mode = DISPLAY_MODES.EDIT_RECIPE
        self.buttons.current_view = EditRecipe(self,
                                              self.im_size, self.center,
                                              recipe=recipe,
                                              recipe_manager=self.recipes_manager,
                                              deactivate_command=self.enter_recipe_selection)
        self.refresh(0.0)
    
    ################ VIEW MANAGEMENT ################

    def update_views(self, selected_types: DISPLAY_TYPES):
        # Clear only the selectable views, not the timer
        for v in self.views:
            if v.ui is not None:
                v.ui.destroy()
        self.views.clear()

        if selected_types & DISPLAY_TYPES.NUMBER:
            number_view = NumberView(self.actions, self.im_size, self.center)
            self.views.append(number_view)

        if selected_types & DISPLAY_TYPES.CIRCLE:
            circle_view = CircleView(self.actions, self.im_size, self.center)
            self.views.append(circle_view)


    def refresh(self, weight: float):
        ims = []

        if self.curr_mode == DISPLAY_MODES.MAIN:
            # Always include timer and button view
            if self.timer_view:
                timer_im = self.timer_view.update_weight(weight)
                button_im = self.buttons.update_weight(weight)
                ims.append(timer_im)
                ims.append(button_im)
            
            # Add other selected views
            for view in self.views:
                im = view.update_weight(weight)
                ims.append(im)
        
        else:
            button_im = self.buttons.update_weight(weight)
            ims.append(button_im)
            recipe_im = self.buttons.current_view.update_weight(weight)
            ims.append(recipe_im)

            
        self.canvas.delete("all")
        # Combine images by logical_and
        if ims:
            combined_im = ims[0]
            for im in ims[1:]:
                combined_im = ImageChops.invert(ImageChops.logical_xor(combined_im, im))
            
            # Convert PIL image to bytes
            buffer = io.BytesIO()
            combined_im.save(buffer, format='PNG')
            buffer.seek(0)
            
            # Load into PhotoImage and display on canvas
            self.photo = PhotoImage(data=buffer.getvalue())
            self.canvas.create_image(0, 0, anchor="nw", image=self.photo)