/**
 * Asking for a track from an album's tracklist.
 *
 * The badge on an unowned row is a `<button>` that files a durable
 * request, and its state is computed at render time from the download
 * store — `libraryStatusFor(owned, mbid)` reads `requestFor(mbid)` out
 * of the cached list.
 *
 * That is what made this fail. The page's `downloadStore` subscription
 * assigned `canDownload` and re-synced `isRequested` for the *release
 * group*, and neither of those changes when a **track** is requested,
 * so Lit saw no reactive property change and never re-rendered. The
 * request was filed, the Downloads tab showed it, and the badge stayed
 * on a plus reading "not in your library" — a control that appears to
 * do nothing, which is exactly what the badge was made a button to stop
 * being.
 *
 * The second assertion is the row's own: the badge is not revealed on
 * hover. A mark on the rows you do *not* have is the information on
 * this page, and one that only exists under the pointer cannot be seen,
 * counted, or reached by a finger.
 */
import { describe, expect, it, beforeEach } from 'vitest';
import type { LitElement } from 'lit';

import '@components/explore-album-details/explore-album-details';
import { stub, flush, resetHarness } from '@test/support/harness';
import { fixture, shadow, shadowAll } from '@test/support/render';

type StoredRequest = {
  id: number;
  mbid: string;
  entity: string;
  libraryId: number;
  artist: string;
  title: string;
  state: string;
  attempts: number;
};

/** The request list the store reads, mutated by the stubbed AddRequest
 *  exactly as the backend's own list would be. */
let requests: StoredRequest[] = [];

function track(n: number, owned: boolean) {
  return {
    position: n,
    discNumber: 1,
    title: `Track ${n}`,
    length: 200000,
    mbid: `mbid-${n}`,
    inLibrary: owned,
  };
}

/** An album with one owned track and one that is not here. */
async function albumWithAnUnownedTrack(): Promise<LitElement> {
  const el = await fixture<LitElement>('explore-album-details', {
    albumName: 'Glass Harbour',
    releaseGroupMBID: 'rg-1',
  });

  const tracks = [track(1, true), track(2, false)];

  stub('library.Library.GetFilePathsByRecordingMBIDs', {
    'mbid-1': ['/music/mbid-1.mp3'],
  });

  Object.assign(el, {
    versionEntries: [
      {
        key: 'v1',
        label: '2019',
        sublabel: '2 tracks',
        tracks,
      },
    ],
    selectedVersionKey: 'v1',
    loadingReleases: false,
    loadingInfo: false,
  });
  el.requestUpdate();
  await flush();
  await el.updateComplete;

  return el;
}

const badges = (el: LitElement) =>
  shadowAll(el, 'library-status-indicator.track-request');

describe('requesting a track from the album tracklist', () => {
  beforeEach(async () => {
    resetHarness();
    requests = [];

    stub('library.Library.GetFilePathsByRecordingMBIDs', {});
    stub('library.Library.GetFilePathsByAlbums', {});
    stub('library.Library.GetAlbumTracks', []);
    stub('library.Library.GetAllLibrariesWithTrackCounts', [
      { id: 1, name: 'Music', path: '/music', trackCount: 1 },
    ]);

    stub('download.Service.ProviderKinds', []);
    stub('download.Service.ListProviders', []);
    stub('download.Service.ListDownloads', []);
    stub('download.Service.ListRequests', () => requests);
    stub('download.Service.AddRequest', (input: Record<string, unknown>) => {
      const id = requests.length + 1;

      requests.push({
        id,
        mbid: String(input.mbid),
        entity: String(input.entity),
        libraryId: Number(input.libraryId),
        artist: String(input.artist ?? ''),
        title: String(input.title ?? ''),
        state: 'wanted',
        attempts: 0,
      });

      return id;
    });
  });

  it('marks the row as queued without a reload', async () => {
    const el = await albumWithAnUnownedTrack();

    // Only the unowned row offers one: there is nothing left to ask for
    // on a track there is a file for.
    const [badge] = badges(el);

    expect(badge).toBeTruthy();
    expect(badge?.getAttribute('status')).toBe('not-in-library');

    shadow<HTMLElement>(badge!, 'button')?.click();
    await flush();
    await el.updateComplete;

    expect(requests.map((r) => r.mbid)).toEqual(['mbid-2']);
    expect(badges(el)[0]?.getAttribute('status')).toBe('queued');
  });

  it('shows the badge without being hovered', async () => {
    const el = await albumWithAnUnownedTrack();
    const [badge] = badges(el);

    // The old rule hid it at `opacity: 0` until `:hover`. Computed
    // opacity is the assertion rather than the absence of a rule,
    // because the rule could come back under another selector.
    expect(getComputedStyle(badge!).opacity).toBe('1');
  });
});