class ButtonVariant(Enum):
    DEFAULT = "default"     # Standard button styling
    ACCENT = "accent"       # Primary action/emphasized styling
    HYPERLINK = "hyperlink" # Text-like button styling 
    TOGGLE = "toggle"       # Toggleable state button

from fluentflet.components import Button, ButtonVariant
from fluentflet.utils import FluentIcon, FluentIcons

# Text button
basic_button = Button(
    "Click Me", 
    variant=ButtonVariant.DEFAULT,
    on_click=lambda e: print("Clicked!")
)

# Icon button with accent
icon_button = Button(
    content=FluentIcon(FluentIcons.ADD), 
    variant=ButtonVariant.ACCENT
)

# Toggle button
toggle = Button(
    "Toggle Me",
    variant=ButtonVariant.TOGGLE,
    on_click=lambda e: print(f"Toggled: {toggle.is_toggled}")
)

class CheckState(Enum):
    UNCHECKED = "unchecked"       # Box is empty
    CHECKED = "checked"           # Box has checkmark
    INDETERMINATE = "indeterminate" # Box has dash (mixed state)

from fluentflet.components import Checkbox, CheckState

# Basic checkbox
checkbox = Checkbox(
    label="Enable feature",
    on_change=lambda state: print(f"State: {state}")
)

# Tri-state checkbox
tristate = Checkbox(
    label="Select files",
    three_state=True,
    state=CheckState.INDETERMINATE
)

# Disabled checkbox 
disabled = Checkbox(
    label="Unavailable option",
    disabled=True,
    state=CheckState.CHECKED
)

from fluentflet.components import Dialog, Button, ButtonVariant

# Simple dialog
dialog = Dialog(
    title="Confirm Action",
    content=ft.Text("Are you sure you want to proceed?")
)

# Custom dialog with multiple actions
custom_dialog = Dialog(
    title="Save Changes",
    content=ft.Column([
        ft.Text("Save current changes?"),
        ft.TextField(label="Comment")
    ]),
    actions=[
        Button("Save", variant=ButtonVariant.ACCENT),
        Button("Don't Save"),
        Button("Cancel")
    ]
)

# Show dialog
page.overlay.append(dialog)
dialog.show()

from fluentflet.components import Dropdown

# Simple string options
dropdown = Dropdown(
    options=["Option 1", "Option 2", "Option 3"],
    on_select=lambda value: print(f"Selected: {value}")
)

# Custom control options
dropdown_with_icons = Dropdown(
    options=[
        ft.Row([
            ft.Icon(ft.icons.SETTINGS),
            ft.Text("Settings")
        ]),
        ft.Row([
            ft.Icon(ft.icons.PERSON),
            ft.Text("Profile")
        ])
    ],
    max_width=200
)

from fluentflet.components import Expander

# Simple text expander
expander = Expander(
    header="Click to Expand",
    content=ft.Text("Expanded content here"),
    expand=False
)

# Complex expander with custom header
expander = Expander(
    header=ft.Row([
        ft.Icon(ft.icons.SETTINGS),
        ft.Text("Advanced Settings")
    ]),
    content=ft.Column([
        ft.TextField(label="Setting 1"),
        ft.TextField(label="Setting 2")
    ])
)

from fluentflet.components import ListItem

# Simple list item
item = ListItem(
    content=ft.Text("List Item 1"),
    on_click=lambda _: print("Clicked")
)

# Complex list item
item = ListItem(
    content=ft.Row([
        ft.Icon(ft.icons.PERSON),
        ft.Column([
            ft.Text("John Doe"),
            ft.Text("[email protected]", size=12)
        ])
    ]),
    selected=True
)

# List of items
items_list = ft.ListView(
    controls=[
        ListItem(content=ft.Text(f"Item {i}"))
        for i in range(5)
    ]
)

from fluentflet.components import ProgressRing

# Indeterminate progress
loading = ProgressRing()

# Determinate progress
progress = ProgressRing(value=0.75)

# Custom styled progress
custom = ProgressRing(
    value=0.5,
    stroke_width=5,
    width=100,
    height=100
)

from fluentflet.components import Radio, RadioGroup

# Single radio button
radio = Radio(
    value="option1",
    label="Option 1",
    disabled=False
)

# Radio group
radio_group = RadioGroup(
    content=ft.Column([
        Radio(value="small", label="Small"),
        Radio(value="medium", label="Medium"),
        Radio(value="large", label="Large")
    ]),
    value="medium",
    on_change=lambda value: print(f"Selected: {value}")
)

class SliderOrientation(Enum):
    HORIZONTAL = "horizontal"
    VERTICAL = "vertical"

from fluentflet.components import Slider, SliderOrientation

# Horizontal slider
slider = Slider(
    value=50,
    min=0,
    max=100,
    on_change=lambda e: print(f"Value: {e.current_value}")
)

# Vertical slider
vertical_slider = Slider(
    value=0.5,
    min=0,
    max=1,
    orientation=SliderOrientation.VERTICAL,
    size=150
)

# Custom range slider
custom = Slider(
    value=-50,
    min=-100,
    max=100,
    disabled=False
)

from fluentflet.components import TextBox
from fluentflet.utils import FluentIcons

# Basic textbox
textbox = TextBox(
    placeholder="Enter text",
    width=300
)

# Password textbox
password = TextBox(
    placeholder="Password",
    password=True
)

# TextBox with prefix and suffix
url_input = TextBox(
    placeholder="Enter domain name",
    prefix="https://",
    suffix=".com",
    width=300
)

# Textbox with actions
textbox_with_actions = TextBox(
    placeholder="Search",
    width=400
)
textbox_with_actions.add_action(
    icon=FluentIcons.SEARCH,
    on_click=lambda _: print("Search clicked"),
    tooltip="Search"
)
textbox_with_actions.add_action(
    icon=FluentIcons.DISMISS,
    on_click=lambda _: setattr(textbox_with_actions, 'value', ''),
    tooltip="Clear"
)

from fluentflet.components import Toggle

# Simple toggle
toggle = Toggle(
    value=False,
    label="Enable feature",
    on_change=lambda state: print(f"Toggled: {state}")
)

# Toggle with different labels
toggle = Toggle(
    value=True,
    label={
        "on_content": "Enabled",
        "off_content": "Disabled"
    }
)

# Custom styled toggle
toggle = Toggle(
    label="Custom toggle",
    label_style={
        "size": 16,
        "weight": "bold"
    },
    width=50,
    height=25
)

from fluentflet.components import ToolTip, Button

# Basic tooltip
button = Button("Hover me")
tooltip = ToolTip(
    message="This is a tooltip",
    content=button
)

# Custom styled tooltip
tooltip = ToolTip(
    message="Custom tooltip",
    content=ft.Text("Hover for info"),
    text_style=ft.TextStyle(
        size=14,
        weight=ft.FontWeight.BOLD
    ),
    bgcolor="#333333",
    border_radius=8
)

item = TreeItemData(
    id="root",
    label="Root Item",
    children=[
        TreeItemData(id="child1", label="Child 1"),
        TreeItemData(id="child2", label="Child 2")
    ]
)

data = {
    "Root": {
        "Child1": {
            "GrandChild1": 1.1,
            "GrandChild2": 1.2
        },
        "Child2": 2.0
    }
}

model = DictTreeViewModel()
model.raw_data = data

data = [
    {
        "id": "1",
        "label": "Item 1",
        "children": [
            {
                "id": "1.1",
                "label": "Subitem 1.1"
            }
        ]
    }
]

model = JSONTreeViewModel()
model.raw_data = data

from fluentflet.components import TreeView, DictTreeViewModel

# Basic tree
data = {
    "Root": {
        "Item1": 1.0,
        "Item2": {
            "SubItem1": 2.1,
            "SubItem2": 2.2
        }
    }
}

tree = TreeView(
    data=data,
    model=DictTreeViewModel(),
    on_right_click=lambda item: print(f"Right clicked: {item.label}")
)

# Custom model tree
class MyModel(TreeViewAbstractModel[List[Dict]]):
    def process_data(self):
        for item in self.raw_data:
            self.items.append(TreeItemData(
                id=str(item["id"]),
                label=item["name"],
                value=item["data"]
            ))

tree = TreeView(
    data=my_data,
    model=MyModel()
)

class ToastPosition(Enum):
    TOP_LEFT = "top-left"
    TOP_RIGHT = "top-right"
    TOP_CENTER = "top-center"
    BOTTOM_LEFT = "bottom-left"
    BOTTOM_RIGHT = "bottom-right"
    BOTTOM_CENTER = "bottom-center"

class ToastVariant(Enum):
    SINGLE_LINE = "single-line"  # Compact single line toast
    MULTI_LINE = "multi-line"    # Expanded multi-line toast

class ToastSeverity(Enum):
    INFORMATIONAL = "informational"  # Blue info style
    SUCCESS = "success"              # Green success style
    WARNING = "warning"              # Yellow warning style
    CRITICAL = "critical"            # Red error style

class ToastActionType(Enum):
    NONE = "none"          # No action button
    HYPERLINK = "hyperlink"  # Link style action
    DEFAULT = "default"      # Button style action

def show_toast(
    self,
    title: Optional[str] = None,
    message: Optional[str] = None,
    severity: ToastSeverity | str = ToastSeverity.INFORMATIONAL,
    variant: ToastVariant | str = ToastVariant.SINGLE_LINE,
    action_type: ToastActionType | str = ToastActionType.NONE,
    action_text: Optional[str] = None,
    action_url: Optional[str] = None,
    on_action: Optional[Callable] = None,
    position: Optional[ToastPosition | str] = None,
    duration: int = 3,
    toast: Optional[Toast] = None,
    **kwargs
) -> None

from fluentflet.components import Toast, Toaster, ToastSeverity

def main(page: ft.Page):
    # Create toaster
    toaster = Toaster(
        page=page,
        position="top-right",
        default_toast_duration=5
    )

    # Show simple toast
    toaster.show_toast(
        title="Success!",
        message="Operation completed",
        severity=ToastSeverity.SUCCESS
    )

    # Show toast with action
    toaster.show_toast(
        title="Warning",
        message="Connection lost",
        severity=ToastSeverity.WARNING,
        action_type="default",
        action_text="Retry",
        on_action=lambda: print("Retrying...")
    )

    # Show custom toast
    custom_toast = Toast(
        title="Custom Toast",
        message="With custom styling",
        severity=ToastSeverity.INFORMATIONAL,
        variant=ToastVariant.MULTI_LINE,
        action_type=ToastActionType.HYPERLINK,
        action_text="Learn More",
        action_url="https://example.com"
    )
    toaster.show_toast(toast=custom_toast)

ft.app(target=main)

@property
def blur_effect(self) -> bool:
    """Controls window blur effect on Windows"""
    return self._blur

@blur_effect.setter
def blur_effect(self, value: bool):
    # Only available on Windows
    # Enables/disables acrylic blur effect

@property
def accepts_drops(self) -> bool:
    """Controls file drop acceptance"""
    return self._accepts_drops

@accepts_drops.setter
def accepts_drops(self, value: bool):
    # Enables/disables file drop handling

def enable_drag_and_drop(
    files_callback: Optional[Callable[[List[str]], None]] = None,
    drag_enter_callback: Optional[Callable[[Tuple[int, int]], None]] = None,
    drag_over_callback: Optional[Callable[[Tuple[int, int]], None]] = None,
    drag_leave_callback: Optional[Callable[[], None]] = None
):
    """Enable file drag-drop functionality
    
    Parameters:
    - files_callback: Called with list of dropped file paths
    - drag_enter_callback: Called with (x,y) when drag enters window
    - drag_over_callback: Called with (x,y) while dragging over window
    - drag_leave_callback: Called when drag leaves window
    """

def on_files_dropped(files):
    print("Files dropped:", files)

def on_drag_enter(point):
    print(f"Drag entered at {point}")

page.accepts_drops = True
page.enable_drag_and_drop(
    files_callback=on_files_dropped,
    drag_enter_callback=on_drag_enter
)

class NavigationType(Enum):
    STANDARD = auto()  # Original layout that pushes content
    OVERLAY = auto()   # Navigation overlays the content

from fluentflet import FluentWindow, NavigationType

window = FluentWindow(
    page=page,
    nav_type=NavigationType.OVERLAY,
    navigation_items=[
        {"icon": FluentIcons.HOME, "label": "Home", "route": "/home"},
        {"icon": FluentIcons.SETTINGS, "label": "Settings", "route": "/settings"}
    ]
)

class FluentState:
    """Manages persistent and ephemeral application state"""
    
    def set(self, key: str, value: any, persist: bool = False):
        """Set state value
        
        Parameters:
        - key: State key
        - value: State value
        - persist: If True, saves to session storage
        """
        
    def get(self, key: str, default=None) -> any:
        """Get state value"""
        
    def subscribe(self, key: str, callback: callable):
        """Subscribe to state changes"""

class AppState(FluentState):
    def _load_initial_state(self):
        self._state = {
            "theme": "light",
            "selected_user": None
        }
    
    def set_theme(self, theme: str):
        self.set("theme", theme, persist=True)

window.state = AppState()
window.state.subscribe("theme", lambda t: print(f"Theme changed: {t}"))

def navigate(self, route: str, **params):
    """Navigate to route with optional parameters
    
    Parameters:
    - route: Route path
    - **params: Route parameters
    """

@route("/path")
def view_builder():
    """Route decorator for registering views"""
    return ft.Column([...])

def add_route(self, route: str, view_builder: Callable[..., ft.Control], 
              is_template: bool = False):
    """Register route manually"""

def main(page: ft.Page):
    window = FluentWindow(
        page,
        navigation_items=[
            {"icon": FluentIcons.HOME, "label": "Home", "route": "/"},
            {"icon": FluentIcons.PEOPLE, "label": "Users", "route": "/users"}
        ]
    )

    @window.route("/")
    def home_view():
        return ft.Column([
            ft.Text("Welcome!", size=32),
            Button("View Users", 
                  on_click=lambda _: window.navigate("/users"))
        ])

    @window.route("/users/:user_id", is_template=True)
    def user_profile(user_id: str):
        return ft.Column([
            ft.Text(f"User Profile: {user_id}")
        ])

    window.navigate("/")

ft.app(target=main)