import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { render, screen, fireEvent, waitFor } from '@testing-library/react';
import { RebootOTADialog } from './RebootOTADialog.tsx';
import { ReactNode } from "react";

const rebootOtaMock = vi.fn();
let mockConnection: { rebootOta: (delay: number) => void } | undefined = {
  rebootOta: rebootOtaMock,
};

vi.mock('@core/stores/deviceStore.ts', () => ({
  useDevice: () => ({
    connection: mockConnection,
  }),
}));

vi.mock('@components/UI/Button.tsx', async () => {
  const actual = await vi.importActual('@components/UI/Button.tsx');
  return {
    ...actual,
    Button: (props: any) => <button {...props} />,
  };
});

vi.mock('@components/UI/Input.tsx', async () => {
  const actual = await vi.importActual('@components/UI/Input.tsx');
  return {
    ...actual,
    Input: (props: any) => <input {...props} />,
  };
});

vi.mock('@components/UI/Dialog.tsx', () => {
  return {
    Dialog: ({ children }: { children: ReactNode }) => <div>{children}</div>,
    DialogContent: ({ children }: { children: ReactNode }) => <div>{children}</div>,
    DialogHeader: ({ children }: { children: ReactNode }) => <div>{children}</div>,
    DialogTitle: ({ children }: { children: ReactNode }) => <h1>{children}</h1>,
    DialogDescription: ({ children }: { children: ReactNode }) => <p>{children}</p>,
    DialogClose: () => null,
  };
});


describe('RebootOTADialog', () => {
  beforeEach(() => {
    vi.useFakeTimers();
    rebootOtaMock.mockClear();
  });

  afterEach(() => {
    vi.useRealTimers();
  });

  it('renders dialog with default input value', () => {
    render(<RebootOTADialog open={true} onOpenChange={() => { }} />);
    expect(screen.getByPlaceholderText(/enter delay/i)).toHaveValue(5);
    expect(screen.getByText(/schedule reboot/i)).toBeInTheDocument();
    expect(screen.getByText(/reboot to ota mode now/i)).toBeInTheDocument();
  });

  it('schedules a reboot with delay and calls rebootOta', async () => {
    const onOpenChangeMock = vi.fn();
    render(<RebootOTADialog open={true} onOpenChange={onOpenChangeMock} />);

    fireEvent.change(screen.getByPlaceholderText(/enter delay/i), {
      target: { value: '3' },
    });

    fireEvent.click(screen.getByText(/schedule reboot/i));

    expect(screen.getByText(/reboot has been scheduled/i)).toBeInTheDocument();

    vi.advanceTimersByTime(3000);

    await waitFor(() => {
      expect(rebootOtaMock).toHaveBeenCalledWith(0);
      expect(onOpenChangeMock).toHaveBeenCalledWith(false);
    });
  });

  it('triggers an instant reboot', async () => {
    const onOpenChangeMock = vi.fn();
    render(<RebootOTADialog open={true} onOpenChange={onOpenChangeMock} />);

    fireEvent.click(screen.getByText(/reboot to ota mode now/i));

    await waitFor(() => {
      expect(rebootOtaMock).toHaveBeenCalledWith(5);
      expect(onOpenChangeMock).toHaveBeenCalledWith(false);
    });
  });

  it('does not call reboot if connection is undefined', async () => {
    const onOpenChangeMock = vi.fn();

    // simulate no connection
    mockConnection = undefined;

    render(<RebootOTADialog open={true} onOpenChange={onOpenChangeMock} />);

    fireEvent.click(screen.getByText(/schedule reboot/i));
    vi.advanceTimersByTime(5000);

    await waitFor(() => {
      expect(rebootOtaMock).not.toHaveBeenCalled();
      expect(onOpenChangeMock).not.toHaveBeenCalled();
    });

    // reset connection for other tests
    mockConnection = { rebootOta: rebootOtaMock };
  });

});