import * as Sentry from '@sentry/browser'
import { useQuery } from '@tanstack/react-query'
import { invoke } from '@tauri-apps/api/core'
import { initHostStore, useHostStore } from '../store/host'
import { usePersistedStore } from '../store/persisted'
import type { ScheduledTask } from '../types/schedules'
import { LOCAL_HOST_ID } from './hosts'
import { type RcRequest, type TaskRequestInput, buildTaskRequests } from './rclone/requests'

// Orchestration between the zustand host store (task definitions — the source of truth) and the
// Rust OS scheduler (registration reality). Registration is always an upsert, so the startup
// reconcile() self-heals deleted OS artifacts, moved app bundles, and restored backups.
//
// Scheduling is LOCAL-HOST-ONLY: tasks stored under remote hosts stay inert.

export interface SchedulerSupport {
    supported: boolean
    reason?: string
}

export interface SchedulerJobSpec {
    schemaVersion: 1
    taskId: string
    hostId: string
    name: string
    operation: ScheduledTask['operation']
    cron: string
    configId: string
    binary: 'app-default' | string
    maxRunSeconds: number
    verboseLogging: boolean
    runMode: 'system' | 'user'
    requests: RcRequest[]
}

export interface SchedulerTaskStatus {
    taskId: string
    installed: boolean
    enabled: boolean
    running: boolean
    lastFinished?: {
        runId: string
        ts: string
        success: boolean
        error?: string
        durationMs: number
        jobids?: number[]
        stats?: { bytes?: number; transfers?: number; errors?: number }
        /** Synthesized: the run left a started event but no finished one (crash/power loss). */
        interrupted?: boolean
    }
    /** Backend health warning — installed+enabled but the OS won't fire it (e.g. the macOS
     * background item was toggled off in System Settings). */
    warning?: string
}

export type SchedulerHistoryLine =
    | { event: 'started'; runId: string; ts: string; pid: number; hostId: string }
    | {
          event: 'finished'
          runId: string
          ts: string
          success: boolean
          error?: string
          durationMs: number
          jobids?: number[]
          stats?: { bytes?: number; transfers?: number; errors?: number }
      }
    | { event: 'skipped'; ts: string; reason: string }

/** Max run time bounds, in hours. The wire format (JobSpec.maxRunSeconds) stays in seconds. */
export const DEFAULT_MAX_RUN_HOURS = 24
export const MAX_RUN_HOURS_LIMIT = 120

function clampMaxRunHours(hours: number | undefined): number {
    if (!Number.isFinite(hours)) {
        return DEFAULT_MAX_RUN_HOURS
    }
    return Math.min(Math.max(Math.round(hours as number), 1), MAX_RUN_HOURS_LIMIT)
}

let cachedSupport: SchedulerSupport | null = null

export async function schedulerSupported(): Promise<SchedulerSupport> {
    if (!cachedSupport) {
        cachedSupport = await invoke<SchedulerSupport>('scheduler_supported')
    }
    return cachedSupport
}

export function useSchedulerSupported() {
    return useQuery({
        queryKey: ['scheduler', 'supported'],
        queryFn: schedulerSupported,
        staleTime: Number.POSITIVE_INFINITY,
    })
}

/**
 * Whether scheduling can actually work here: the current host is the local machine AND the OS
 * backend reports support. Unresolved support counts as unavailable. Shared by the operation
 * pages (to gate the Cron section + footer Schedule button) and the footer.
 */
export function useSchedulingAvailable(): boolean {
    const currentHostId = usePersistedStore((s) => s.currentHostId) ?? LOCAL_HOST_ID
    const support = useSchedulerSupported()
    return currentHostId === LOCAL_HOST_ID && (support.data?.supported ?? false)
}

export interface CronValidation {
    valid: boolean
    error?: string
    /** Next local fire times (RFC3339), computed by the same Rust matcher the runner uses —
     * the only preview source that can't disagree with what the OS schedule will do. */
    nextRuns: string[]
}

export async function schedulerValidateCron(cron: string) {
    return invoke<CronValidation>('scheduler_validate_cron', { cron })
}

export async function schedulerStatus(hostId: string) {
    return invoke<SchedulerTaskStatus[]>('scheduler_status', { hostId })
}

export async function schedulerReadHistory(taskId: string, limit?: number) {
    return invoke<SchedulerHistoryLine[]>('scheduler_read_history', { taskId, limit })
}

export async function schedulerRunNow(taskId: string) {
    return invoke('scheduler_run_now', { taskId })
}

export async function schedulerReadLog(taskId: string, which: 'runner' | 'daemon') {
    return invoke<{ content: string; truncated: boolean }>('scheduler_read_log', {
        taskId,
        which,
    })
}

function buildJobSpec(task: ScheduledTask): SchedulerJobSpec {
    return {
        schemaVersion: 1,
        taskId: task.id,
        hostId: LOCAL_HOST_ID,
        name: task.name ?? task.operation,
        operation: task.operation,
        cron: task.cron,
        configId: task.configId,
        binary: task.binaryPath,
        maxRunSeconds: clampMaxRunHours(task.maxRunHours) * 3600,
        verboseLogging: task.verboseLogging ?? false,
        runMode: task.runMode ?? 'user',
        // Pre-serialized here, at save time, by the exact same builders the live start* path
        // uses — the runner just POSTs them. Throws when the args can't serialize.
        requests: buildTaskRequests(task),
    }
}

async function registerTask(task: ScheduledTask): Promise<void> {
    const spec = buildJobSpec(task)
    // One command: the artifact is installed directly in the target enabled state. A separate
    // set_enabled step used to leave disabled tasks briefly armed (and, when it failed, running
    // against the user's intent — or flagged as unregistered although active).
    await invoke('scheduler_register', { spec, enabled: task.isEnabled })
}

function isCurrentHostLocal() {
    return (usePersistedStore.getState().currentHostId ?? LOCAL_HOST_ID) === LOCAL_HOST_ID
}

function assertLocalHost() {
    if (!isCurrentHostLocal()) {
        throw new Error('Scheduling is only available on your local machine')
    }
}

async function assertSupported() {
    const support = await schedulerSupported()
    if (!support.supported) {
        throw new Error(support.reason ?? 'Scheduling is not available on this system')
    }
}

/**
 * Creates a task, registers it with the OS scheduler, and returns its id. On registration
 * failure the task is kept (with the error stored on it) — never silently lost; the startup
 * reconcile retries. isEnabled always reflects user intent, never system state.
 */
export async function createScheduledTask(input: {
    name: string
    operation: ScheduledTask['operation']
    cron: string
    args: ScheduledTask['args']
    /** Defaults to the active config when omitted. */
    configId?: string
    /** Defaults to 'app-default' when omitted. */
    binaryPath?: string
    /** Defaults to 'user' (only runs while logged in) when omitted. */
    runMode?: 'system' | 'user'
}): Promise<string> {
    assertLocalHost()
    await assertSupported()

    const validation = await schedulerValidateCron(input.cron)
    if (!validation.valid) {
        throw new Error(validation.error ?? 'Invalid cron expression')
    }

    const hostState = useHostStore.getState()
    const configId = input.configId ?? hostState.activeConfigId
    if (!configId) {
        throw new Error('No active config file')
    }
    if (!hostState.configFiles.some((config) => config.id === configId)) {
        throw new Error('The selected config file no longer exists')
    }

    const task = {
        name: input.name,
        operation: input.operation,
        cron: input.cron,
        args: input.args,
        isEnabled: true,
        configId,
        binaryPath: input.binaryPath ?? 'app-default',
        runMode: input.runMode ?? 'user',
    } as Omit<ScheduledTask, 'id'>

    // Serialization must succeed before anything persists. (Callers guarantee the operation/args
    // correlation via useScheduleTask's generic; Omit<> flattens the discriminated union, hence
    // the cast.)
    buildTaskRequests({ operation: input.operation, args: input.args } as TaskRequestInput)

    const id = hostState.addScheduledTask(task)
    const stored = useHostStore.getState().scheduledTasks.find((t) => t.id === id)
    if (!stored) {
        throw new Error('Failed to save the scheduled task')
    }

    try {
        await registerTask(stored)
    } catch (error) {
        const registrationError = error instanceof Error ? error.message : String(error)
        useHostStore.getState().updateScheduledTask(id, { registrationError })
        throw new Error(
            `The schedule was saved but could not be registered with the system: ${registrationError}`
        )
    }

    return id
}

/**
 * Updates a task and re-registers it (upsert). On a remote host this is a store-only edit —
 * remote tasks are inert in v1 and must never touch the local OS scheduler.
 */
export async function updateScheduledTask(
    id: string,
    patch: Partial<ScheduledTask>
): Promise<void> {
    if (!isCurrentHostLocal()) {
        useHostStore.getState().updateScheduledTask(id, patch)
        return
    }

    await assertSupported()

    if (patch.cron) {
        const validation = await schedulerValidateCron(patch.cron)
        if (!validation.valid) {
            throw new Error(validation.error ?? 'Invalid cron expression')
        }
    }

    const store = useHostStore.getState()
    store.updateScheduledTask(id, { ...patch, registrationError: undefined })
    const merged = useHostStore.getState().scheduledTasks.find((t) => t.id === id)
    if (!merged) {
        throw new Error('Task not found')
    }

    try {
        await registerTask(merged)
    } catch (error) {
        const registrationError = error instanceof Error ? error.message : String(error)
        useHostStore.getState().updateScheduledTask(id, { registrationError })
        throw new Error(`The task was saved but could not be registered: ${registrationError}`)
    }
}

/**
 * Removes the task. The OS unregister removes the job file even when the OS-level uninstall
 * fails, so a surviving trigger self-heals on its next fire (the runner finds no job file,
 * removes the trigger, and exits). Remote-host tasks are store-only.
 */
export async function removeScheduledTask(id: string): Promise<void> {
    if (isCurrentHostLocal()) {
        try {
            await invoke('scheduler_unregister', { taskId: id, hostId: LOCAL_HOST_ID })
        } catch (error) {
            console.error(
                '[scheduler] unregister failed; the trigger self-heals on next fire',
                error
            )
        }
    }
    useHostStore.getState().removeScheduledTask(id)
}

export async function setScheduledTaskEnabled(id: string, enabled: boolean): Promise<void> {
    const task = useHostStore.getState().scheduledTasks.find((t) => t.id === id)
    if (!task) {
        throw new Error('Task not found')
    }

    // Remote-host tasks are inert — the toggle is a definition-only edit.
    if (!isCurrentHostLocal()) {
        useHostStore.getState().updateScheduledTask(id, { isEnabled: enabled })
        return
    }

    // Enabling a task whose registration previously failed retries the full registration.
    if (enabled && task.registrationError) {
        await updateScheduledTask(id, { isEnabled: true })
        return
    }

    // Disabling a task whose registration failed: an OS artifact may STILL exist (a failed
    // edit leaves the previous artifact active; a failed mode flip can leave one in the other
    // backend). The Rust side sweeps every backend and treats "no artifact anywhere" as
    // success, so always ask it — a real disable failure must surface rather than leave the
    // task firing while the UI says paused.
    if (!enabled && task.registrationError) {
        await invoke('scheduler_set_enabled', { taskId: id, enabled: false })
        useHostStore.getState().updateScheduledTask(id, { isEnabled: false })
        return
    }

    // OS first, store second — a failed OS call must not leave the UI claiming a state the
    // scheduler doesn't have.
    await invoke('scheduler_set_enabled', { taskId: id, enabled })
    useHostStore.getState().updateScheduledTask(id, { isEnabled: enabled })
}

/**
 * Startup/host-switch reconciliation — idempotent, runs on EVERY start. Re-registers every
 * local task (heals exe-path drift, deleted OS artifacts, and performs the one-time migration
 * registration after the v3 store migrate) and unregisters strays the store no longer knows.
 */
export async function reconcile(): Promise<void> {
    const support = await schedulerSupported()
    if (!support.supported) {
        console.log('[scheduler] unsupported, skipping reconcile:', support.reason)
        return
    }

    // Never reconcile against a non-local host store: the stray sweep would treat every real
    // local registration as unknown and destroy it.
    if (!isCurrentHostLocal()) {
        console.log('[scheduler] current host is remote, skipping reconcile')
        return
    }

    const taskIds = useHostStore.getState().scheduledTasks.map((task) => task.id)

    for (const id of taskIds) {
        // Re-read at registration time: the UI is usable while reconcile runs, so a user edit
        // mid-loop must win — registering a stale snapshot would silently revert it in the job
        // file and OS artifact while the store shows the new definition.
        const task = useHostStore.getState().scheduledTasks.find((t) => t.id === id)
        if (!task) {
            continue
        }
        try {
            await registerTask(task)
            if (task.registrationError) {
                useHostStore.getState().updateScheduledTask(task.id, {
                    registrationError: undefined,
                })
            }
        } catch (error) {
            // registrationError only — isEnabled stays user intent, so a transient failure
            // (user bus not ready yet, launchctl hiccup) heals on the next reconcile instead of
            // permanently pausing the task.
            const registrationError = error instanceof Error ? error.message : String(error)
            console.error('[scheduler] failed to register task', task.id, registrationError)
            useHostStore.getState().updateScheduledTask(task.id, { registrationError })
        }
    }

    // Strays: OS registrations whose task no longer exists in the store.
    try {
        const statuses = await schedulerStatus(LOCAL_HOST_ID)
        const known = new Set(useHostStore.getState().scheduledTasks.map((t) => t.id))
        for (const status of statuses) {
            if (!known.has(status.taskId)) {
                console.log('[scheduler] unregistering stray task', status.taskId)
                await invoke('scheduler_unregister', {
                    taskId: status.taskId,
                    hostId: LOCAL_HOST_ID,
                })
            }
        }
    } catch (error) {
        console.error('[scheduler] stray sweep failed', error)
    }

    // Artifact-only leftovers: an OS artifact whose job file is gone (a failed uninstall after
    // the job file was already removed). A DISABLED leftover never fires, so the runner's
    // fire-time self-heal can never reach it — this sweep is the only cleanup path. Runs last:
    // the loop above just re-registered every stored task, so their job files protect them.
    try {
        const swept = await invoke<number>('scheduler_sweep_orphans')
        if (swept > 0) {
            console.log('[scheduler] swept orphaned artifacts:', swept)
        }
    } catch (error) {
        console.error('[scheduler] orphan sweep failed', error)
    }
}

let initialized = false

/**
 * Called ONLY from the hidden main window (single writer, like initJobWatcher): reconciles at
 * startup and again whenever the user switches back to the local host.
 */
export async function initScheduler(): Promise<void> {
    if (initialized) {
        return
    }
    initialized = true

    const isLocal = () =>
        (usePersistedStore.getState().currentHostId ?? LOCAL_HOST_ID) === LOCAL_HOST_ID

    let lastHostId = usePersistedStore.getState().currentHostId
    usePersistedStore.subscribe((state) => {
        if (state.currentHostId !== lastHostId) {
            lastHostId = state.currentHostId
            if (isLocal()) {
                // This window's useHostStore must be re-pointed at the local host BEFORE
                // reconciling — nothing else in the hidden main window re-inits it on host
                // switch, and reconciling against a stale (remote) host store would sweep away
                // every genuine local registration as a stray.
                initHostStore(LOCAL_HOST_ID)
                    .then(() => reconcile())
                    .catch((error) => {
                        console.error('[scheduler] reconcile after host switch failed', error)
                    })
            }
        }
    })

    if (!isLocal()) {
        return
    }

    try {
        await reconcile()
    } catch (error) {
        console.error('[scheduler] startup reconcile failed', error)
        Sentry.captureException(error)
    }
}