import { afterEach, describe, expect, it, vi } from 'vitest';
import { mock } from 'vitest-mock-extended';

import { FoldersExecutor } from '../../../src/card-controller/folders/executor';
import type { HAFoldersEngine } from '../../../src/card-controller/folders/ha/engine';
import type { FolderQuery } from '../../../src/card-controller/folders/types';
import { TemplateManager } from '../../../src/card-controller/templates';
import type { FolderConfig } from '../../../src/config/schema/folders';
import { QuerySource } from '../../../src/query-source';
import type { Endpoint } from '../../../src/types';
import { ViewFolder } from '../../../src/view/item';
import { createFolder, createHASS } from '../../test-utils';
import { TestViewMedia } from '../../view/test-utils';

vi.mock('../../../src/card-controller/folders/ha/engine');
vi.mock('../../../../src/utils/ha/download');

describe('FoldersExecutor', () => {
  const templateManager = new TemplateManager();

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

  describe('getItemCapabilities', () => {
    it('should not get capabilities for non-folder media', () => {
      const item = new TestViewMedia({ folder: null });
      const executor = new FoldersExecutor(templateManager);

      expect(executor.getItemCapabilities(item)).toBeNull();
    });

    it('should not get capabilities for non-existent folder engine', () => {
      const folder: FolderConfig = {
        type: 'UNKNOWN',
      } as unknown as FolderConfig;
      const item = new TestViewMedia({ folder });
      const executor = new FoldersExecutor(templateManager);

      expect(executor.getItemCapabilities(item)).toBeNull();
    });

    it('should get capabilities for HA folder engine', () => {
      const folder = createFolder();
      const item = new TestViewMedia({ folder });

      const capabilities = {
        canFavorite: false,
        canDownload: true,
      };
      const haFolderEngine = mock<HAFoldersEngine>();
      haFolderEngine.getItemCapabilities.mockReturnValue(capabilities);

      const executor = new FoldersExecutor(templateManager, {
        ha: haFolderEngine,
      });

      expect(executor.getItemCapabilities(item)).toEqual(capabilities);
    });
  });

  describe('getDefaultQueryParameters', () => {
    it('should return null for non-existent folder engine', () => {
      const folder: FolderConfig = {
        type: 'UNKNOWN',
      } as unknown as FolderConfig;
      const executor = new FoldersExecutor(templateManager);

      expect(executor.getDefaultQueryParameters(folder)).toBeNull();
    });

    it('should get default query parameters for HA folder engine', () => {
      const folder = createFolder();
      const haFolderEngine = mock<HAFoldersEngine>();
      const expectedQuery: FolderQuery = {
        source: QuerySource.Folder,
        folder: folder,
        path: [{}],
      };
      haFolderEngine.getDefaultQueryParameters.mockReturnValue(expectedQuery);

      const executor = new FoldersExecutor(templateManager, {
        ha: haFolderEngine,
      });

      expect(executor.getDefaultQueryParameters(folder)).toEqual(expectedQuery);
    });
  });

  describe('getDownloadPath', () => {
    it('should not get download path for non-existent folder engine', async () => {
      const folder: FolderConfig = {
        type: 'UNKNOWN',
      } as unknown as FolderConfig;
      const item = new TestViewMedia({ folder });
      const executor = new FoldersExecutor(templateManager);

      expect(await executor.getDownloadPath(createHASS(), item)).toBeNull();
    });

    it('should get download path for HA folder engine', async () => {
      const endpoint: Endpoint = { endpoint: '/media', sign: false };
      const haFolderEngine = mock<HAFoldersEngine>();
      haFolderEngine.getDownloadPath.mockResolvedValue(endpoint);

      const executor = new FoldersExecutor(templateManager, {
        ha: haFolderEngine,
      });
      const item = new TestViewMedia({ folder: createFolder() });
      expect(await executor.getDownloadPath(createHASS(), item)).toEqual(endpoint);
    });
  });

  describe('favorite', () => {
    it('should not favorite non-existent folder engine', async () => {
      const folder: FolderConfig = {
        type: 'UNKNOWN',
      } as unknown as FolderConfig;
      const item = new TestViewMedia({ folder });
      const executor = new FoldersExecutor(templateManager);

      await executor.favorite(createHASS(), item, true);

      // No observable effect.
    });

    it('should favorite', async () => {
      const haFolderEngine = mock<HAFoldersEngine>();
      const executor = new FoldersExecutor(templateManager, {
        ha: haFolderEngine,
      });

      const hass = createHASS();
      const item = new TestViewMedia({ folder: createFolder() });

      await executor.favorite(hass, item, true);

      expect(haFolderEngine.favorite).toHaveBeenCalledWith(hass, item, true);
    });
  });

  describe('generateChildFolderQuery', () => {
    it('should generate child folder query', () => {
      const folder: FolderConfig = createFolder();
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder,
        path: [{ ha: { id: 'media-source://' } }],
      };
      const viewFolder = new ViewFolder(folder, []);

      const haFolderEngine = mock<HAFoldersEngine>();
      haFolderEngine.generateChildFolderQuery.mockReturnValue(query);
      const executor = new FoldersExecutor(templateManager, { ha: haFolderEngine });

      expect(executor.generateChildFolderQuery(query, viewFolder)).toEqual(query);
      expect(haFolderEngine.generateChildFolderQuery).toHaveBeenCalledWith(
        query,
        viewFolder,
      );
    });

    it('should return null for non-existent folder engine', () => {
      const folder: FolderConfig = {
        type: 'UNKNOWN',
      } as unknown as FolderConfig;
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder,
        path: [{ ha: { id: 'media-source://' } }],
      };
      const viewFolder = new ViewFolder(folder, []);
      const executor = new FoldersExecutor(templateManager);

      expect(executor.generateChildFolderQuery(query, viewFolder)).toBeNull();
    });
  });

  describe('expandFolder', () => {
    it('should reject folders of the wrong type', async () => {
      const query = {
        folder: { type: 'UNKNOWN' },
      } as unknown as FolderQuery;

      const executor = new FoldersExecutor(templateManager);

      expect(await executor.expandFolder(createHASS(), query)).toBeNull();
    });

    it('should expand folder', async () => {
      const folder = createFolder();
      const query: FolderQuery = {
        source: QuerySource.Folder,
        folder,
        path: [{ ha: { id: 'media-source://' } }],
      };

      const mediaItem = new TestViewMedia({
        folder,
        startTime: new Date('2023-04-29T14:27'),
      });
      const folderItem = new ViewFolder(folder, []);

      const haFolderEngine = mock<HAFoldersEngine>();
      haFolderEngine.expandFolder.mockResolvedValue([folderItem, mediaItem, folderItem]);

      const executor = new FoldersExecutor(templateManager, {
        ha: haFolderEngine,
      });
      const hass = createHASS();
      const results = await executor.expandFolder(hass, query);
      expect(results).toEqual([
        // Folder will have been sorted to the front and de-duped.
        folderItem,
        mediaItem,
      ]);
    });
  });

  describe('areResultsFresh', () => {
    it('should return true for non-existent engine', () => {
      const folder: FolderConfig = {
        type: 'UNKNOWN',
      } as unknown as FolderConfig;
      const query: FolderQuery = { source: QuerySource.Folder, folder, path: [{}] };
      const executor = new FoldersExecutor(templateManager);

      expect(executor.areResultsFresh(new Date(), query)).toBe(true);
    });

    it('should get results from HA engine', () => {
      const folder = createFolder();
      const query: FolderQuery = { source: QuerySource.Folder, folder, path: [{}] };
      const haFolderEngine = mock<HAFoldersEngine>();
      haFolderEngine.areResultsFresh.mockReturnValue(false);

      const executor = new FoldersExecutor(templateManager, {
        ha: haFolderEngine,
      });

      expect(executor.areResultsFresh(new Date(), query)).toBe(false);
      expect(haFolderEngine.areResultsFresh).toHaveBeenCalled();
    });
  });
});