// AppEnvironment
#if DEBUG
var devTools: DevToolsEnvironment = .live(connectionMode: .browseOnLaunch)
#endif

// In @main / App body, after the store is created:
store.dispatch(.devTools(.activate))

devTools: .live(connectionMode: .autoConnect)

// At app launch:
store.dispatch(.devTools(.activate))
// → starts browsing "_reduxdevtools._tcp."
// → connects to the first remotedev-server found
// → stops browsing once connected

devTools: .live(connectionMode: .connectOnLaunch(host: "192.168.1.100", port: 8000))

store.dispatch(.devTools(.activate))  // immediately connects

devTools: .live(connectionMode: .browseOnLaunch)

store.dispatch(.devTools(.activate))  // starts browsing

// Present DevToolsState.discoveredServices in your debug UI.
// When user selects one:
store.dispatch(.devTools(.connectToService(selectedService)))
// → resolves host:port automatically and connects

devTools: .live()  // connectionMode defaults to .manual

// From a shake gesture, debug settings screen, etc.:
store.dispatch(.devTools(.connect(host: "192.168.1.100", port: 8000)))
// or
store.dispatch(.devTools(.startBrowsing))
store.dispatch(.devTools(.connectToService(selectedService)))

// Package.swift
.package(url: "https://github.com/SwiftRex/ReduxDevToolsBehavior.git", branch: "master"),

// Target dependency
.product(name: "ReduxDevToolsBehavior", package: "ReduxDevToolsBehavior"),

import ReduxDevToolsBehavior

// AppAction — add a devTools case
enum AppAction: Sendable {
    case counter(CounterAction)
    case settings(SettingsAction)
    #if DEBUG
    case devTools(DevToolsAction)
    #endif
}

// AppState — add a devTools sub-state
struct AppState: Sendable {
    var counter: CounterState
    var settings: SettingsState
    #if DEBUG
    var devTools: DevToolsState = .initial
    #endif
}

// AppEnvironment — add the devTools environment
struct AppEnvironment: Sendable {
    var counter: CounterEnvironment
    var settings: SettingsEnvironment
    #if DEBUG
    var devTools: DevToolsEnvironment = .live()
    #endif
}

import ReduxDevToolsBehavior

let appBehavior = Behavior.combine(
    counterBehavior.lift(
        action: AppAction.prism.counter,
        state: \AppState.counter,
        environment: \AppEnvironment.counter
    ),
    settingsBehavior.lift(
        action: AppAction.prism.settings,
        state: \AppState.settings,
        environment: \AppEnvironment.settings
    ),
    #if DEBUG
    DevToolsBehavior.behaviors(
        action: AppAction.prism.devTools,
        state: \AppState.devTools,
        environment: \AppEnvironment.devTools
    ),
    #endif
)

// In @main / App body, after the store is created:
#if DEBUG
store.dispatch(.devTools(.activate))
#endif

// Manual connect to known IP
store.dispatch(.devTools(.connect(host: "192.168.1.100", port: 8000)))

// Browse and pick from list
store.dispatch(.devTools(.startBrowsing))
// Then when the user picks a discovered service:
store.dispatch(.devTools(.connectToService(selectedService)))

// Or configure the mode in the environment so activate handles it:
// devTools: .live(connectionMode: .connectOnLaunch(host: "192.168.1.100", port: 8000))
// devTools: .live(connectionMode: .browseOnLaunch)

// Automatically uses JSONEncoder for encoding and JSONDecoder for time travel
var devTools: DevToolsEnvironment = .live(for: AppState.self)

// MirrorJSON uses Swift Mirror to encode any value to JSON without Encodable
var devTools: DevToolsEnvironment = .live()

MirrorJSON.encode(AppAction.increment)               // → "\"increment\""
MirrorJSON.encode(AppAction.setText("hi"))           // → "{\"setText\":\"hi\"}"
MirrorJSON.encode(AppAction.load(id: 1, force: false)) // → "{\"load\":{\"id\":1,\"force\":false}}"

let encoder = JSONEncoder()
encoder.keyEncodingStrategy = .convertToSnakeCase

var devTools: DevToolsEnvironment = .live(
    for: AppState.self,        // auto-wires decodeState
    instanceId: "com.myapp",
    encodeAction: { action in
        (try? encoder.encode(action as! Encodable))
            .flatMap { String(data: $0, encoding: .utf8) }
            ?? MirrorJSON.encode(action)
    }
)

var devTools: DevToolsEnvironment = .live(
    instanceId: "com.myapp",
    encodeAction: { action in /* ... */ },
    encodeState: { state in /* ... */ },
    decodeState: { json in /* ... */ }
)

// AppAction — add a restore case
enum AppAction: Sendable {
    // ...
    #if DEBUG
    case devTools(DevToolsAction)
    case restoreState(AppState)      // dispatched during time travel
    #endif
}

// Handle it in your Behavior or Reducer:
case .restoreState(let snapshot):
    state = snapshot

// Environment — auto-wires JSONDecoder
#if DEBUG
var devTools: DevToolsEnvironment = .live(for: AppState.self)
#endif

// Behavior — add extractDevToolsAction + restoreStateAction
#if DEBUG
DevToolsBehavior.behaviors(
    action: AppAction.prism.devTools,
    state: \AppState.devTools,
    environment: \AppEnvironment.devTools,
    extractDevToolsAction: { if case .devTools(let dt) = $0 { return dt }; return nil },
    restoreStateAction: { .restoreState($0) }
)
#endif

var devTools: DevToolsEnvironment = .live(
    instanceId: "my-app",
    decodeState: { json in myCustomDecode(json) }   // returns AppState?
)

DevToolsBehavior.behaviors(
    action: AppAction.prism.devTools,
    state: \AppState.devTools,
    environment: \AppEnvironment.devTools,
    extractDevToolsAction: { if case .devTools(let dt) = $0 { return dt }; return nil },
    restoreStateAction: { .restoreState($0) }
)

// Start browsing
store.dispatch(.devTools(.startBrowsing))

// DevToolsState.discoveredServices fills with DiscoveredService values.
// Present them in a picker; on selection:
store.dispatch(.devTools(.stopBrowsing))

let resolved = try await env.resolveService(selectedService).run().get()
store.dispatch(.devTools(.connect(
    host: resolved.preferredHost ?? "",
    port: resolved.port ?? 8000
)))

var devTools: DevToolsEnvironment = .live(bonjourServiceType: "_myapp._tcp.")