<?php

namespace Gazelle;

use PHPUnit\Framework\TestCase;
use GazelleUnitTest\Helper;
use Gazelle\Enum\CommentType;

define('BUFFER_FOR_BOUNTY', 1024 ** 4); // some upload credit to allow request creation

class RequestTest extends TestCase {
    use Pg;

    protected Request $request;
    protected TGroup  $tgroup;
    protected array   $userList;

    public function setUp(): void {
        // we need two users, one who uploads and one who snatches
        $this->userList = [
            'admin' => Helper::makeUser('req.' . randomString(10), 'request'),
            'user'  => Helper::makeUser('req.' . randomString(10), 'request'),
        ];
        $this->userList['admin']->requestContext()->setViewer($this->userList['admin']);
        $this->userList['admin']->setField('Enabled', '1')->setField('PermissionID', SYSOP)->modify();
        $this->userList['admin']->addBounty(BUFFER_FOR_BOUNTY);
        $this->userList['user']->setField('Enabled', '1')->modify();
    }

    public function tearDown(): void {
        if (isset($this->request)) {
            // testCreate() removes it for an assertion
            $this->request->remove();
        }
        if (isset($this->tgroup)) {
            Helper::removeTGroup($this->tgroup, $this->userList['admin']);
        }
        foreach ($this->userList as $user) {
            $user->requestContext()->unsetViewer();
            $user->remove();
        }
    }

    public function testCreate(): void {
        $admin = $this->userList['admin'];
        $user  = $this->userList['user'];

        $manager       = new Manager\Request();
        $title         = 'phpunit create (x) ' . randomString(6);
        $image         = 'https://example.com/req.jpg';
        $year          = 2002;
        $this->request = Helper::makeRequestMusic($admin, $title, image: $image, year: $year);
        $id = $this->request->id;

        $this->assertInstanceOf(Request::class, $this->request, 'request-create');
        $this->assertFalse($this->request->hasNewVote(), 'request-new-vote');
        $this->assertStringNotContainsString(
            ' (x)',
            $this->request->urlencodeTitle(),
            'request-urlencode-title'
        );
        $this->assertEquals(
            $this->request->created(),
            $this->request->modified(),
            'request-modified'
        );
        $this->assertEquals(
            1,
            $this->request->releaseType(),
            'request-release-type'
        );

        $artistMan  = new Manager\Artist();
        $artistName = 'phpunit req ' . randomString(6);
        $this->assertInstanceOf(
            ArtistRole\Request::class,
            $this->request->artistRole(),
            'request-add-artist-role'
        );
        $this->assertEquals(
            1,
            $this->request->artistRole()->set(
                [ARTIST_MAIN => [$artistName]],
                $user,
            ),
            'request-add-artist-role',
        );
        $this->assertInstanceOf(
            ArtistRole\Request::class,
            $this->request->artistRole(),
            'request-has-artist-role',
        );
        $this->assertInstanceOf(Request\LogCue::class, $this->request->logCue(), 'request-log-cue');
        $this->assertStringContainsString('+', $this->request->urlencodeArtist(), 'request-urlencode-artist');
        $this->assertEquals(
            [ARTIST_MAIN => [$artistName]],
            $this->request->artistRole()->roleNameList(),
            'request-artist-role-name-list',
        );

        $this->assertCount(0, $this->request->tagNameList());
        $nameList = ['phpunit.' . randomString(6), 'phpunit.' . randomString(6)];
        sort($nameList);
        $tagMan   = new Manager\Tag();
        $tag      = $tagMan->create($nameList[0], $admin);
        $this->assertEquals(1, $tag->addRequest($this->request), 'request-add-tag');
        $this->assertEquals(
            1,
            $tagMan->create($nameList[1], $admin)->addRequest($this->request),
            'request-add-second-tag',
        );

        // Request::info() will now succeed
        $this->assertEquals($admin->id, $this->request->userId(), 'request-user-id');
        $this->assertEquals($admin->id, $this->request->ajaxInfo()['requestorId'], 'request-ajax-user-id');
        $this->assertEquals("$artistName – $title [$year]", $this->request->text(), 'request-text');
        $find = $manager->findByArtist($artistMan->findByName($artistName));
        $this->assertCount(1, $find, 'request-find-by-artist');
        $this->assertEquals($id, $find[0]->id, 'request-find-id');

        $location = "requests.php?action=view&id=$id";
        $this->assertEquals($location, $this->request->location(), 'request-location');
        $this->assertEquals(SITE_URL . "/$location", $this->request->publicLocation(), 'request-public-location');
        $this->assertEquals(htmlentities($location), $this->request->url(), 'request-url');
        $this->assertEquals(SITE_URL . '/' . htmlentities($location), $this->request->publicUrl(), 'request-public-url');
        $this->assertEquals(
            "<a href=\"requests.php?action=view&amp;id={$id}\">{$title}</a>",
            $this->request->link(),
            'request-link'
        );
        $artistId = $this->request->artistRole()->idList()[ARTIST_MAIN][0]['id'];
        $artistName = $this->request->artistRole()->idList()[ARTIST_MAIN][0]['name'];
        $this->assertEquals(
            "<a href=\"artist.php?id=$artistId\" dir=\"ltr\">$artistName</a> – {$this->request->title()} [{$this->request->year()}]",
            $this->request->selfLink(),
            'request-self-link'
        );
        $this->assertEquals(
            "<a href=\"artist.php?id=$artistId\" dir=\"ltr\">$artistName</a> – {$this->request->link()} [{$this->request->year()}]",
            $this->request->smartLink(),
            'request-smart-link'
        );

        $this->assertTrue(Helper::recentDate($this->request->created()), 'request-created');
        $this->assertEquals($image, $this->request->image(), 'request-image');
        $this->assertEquals($title, $this->request->title(), 'request-title');
        $this->assertEquals('Album', $this->request->releaseTypeName(), 'request-release-type-name');
        $this->assertEquals($year, $this->request->year(), 'request-year');
        $this->assertNull($this->request->tgroupId(), 'request-no-tgroup');
        $this->assertEquals('UA-7890', $this->request->catalogueNumber(), 'request-can-no');
        $this->assertEquals('Unitest Artists', $this->request->recordLabel(), 'request-rec-label');
        $this->assertEquals(1, $this->request->categoryId(), 'request-cat-id');
        $this->assertEquals(
            'Music',
            $this->request->categoryName(),
            'request-cat-name',
        );
        $this->assertEquals(
            STATIC_SERVER . '/common/noartwork/music.png',
            $this->request->categoryImage(),
            'request-cat-image'
        );
        $this->assertTrue($this->request->hasArtistRole(), 'request-has-artist-role');
        $this->assertInstanceOf(
            ArtistRole\Request::class,
            $this->request->artistRole(),
            'request-artist-role'
        );
        $this->assertEquals(
            $nameList,
            $this->request->flush()->tagNameList(),
            'request-tag-list',
        );
        $this->assertEquals(
            "<a href=\"requests.php?tags={$nameList[0]}\">{$nameList[0]}</a> <a href=\"requests.php?tags={$nameList[1]}\">{$nameList[1]}</a>",
            $this->request->tagLinkList(), 'request-tag-linklist'
        );
        $this->assertFalse($this->request->isFilled(), 'request-not-filled');

        $more = ['phpunit.' . randomString(6), 'phpunit.' . randomString(6), 'phpunit.' . randomString(6)];
        $this->assertEquals(
            3,
            $tagMan->replaceTagList(
                $this->request,
                [$more[0], $more[1], $more[1], $more[2]],
                $user,
            ),
            'request-set-tag'
        );

        $this->assertEquals('This is a unit test description', $this->request->description(), 'request-description');
        $this->assertTrue($this->request->needCue(), 'request-need-cue');
        $this->assertTrue($this->request->needLog(), 'request-need-log');
        $this->assertTrue($this->request->needLogChecksum(), 'request-need-checksum');
        $this->assertEquals(100, $this->request->needLogScore(), 'request-log-score');
        $this->assertEquals('Log (100%) + Cue', $this->request->descriptionLogCue(), 'request-descn-log-cue');
        $this->assertEquals('1', $this->request->legacyLogChecksum(), 'request-legacy-checksum');

        $this->assertEquals(
            ['Lossless', 'V0 (VBR)'],
            array_values($this->request->currentEncoding()),
            'request-cur-encoding',
        );
        $this->assertEquals(
            ['Lossless', 'V0 (VBR)'],
            array_values($this->request->needEncodingList()),
            'request-need-encoding',
        );
        $this->assertEquals(
            'Lossless, V0 (VBR)',
            $this->request->descriptionEncoding(),
            'request-descr-encoding',
        );
        $this->assertEquals(
            'Lossless|V0 (VBR)',
            $this->request->legacyEncodingList(),
            'request-legacy-encoding'
        );
        $this->assertTrue($this->request->needEncoding('Lossless'), 'request-need-encoding-lossless');
        $this->assertFalse($this->request->needEncoding('24bit Lossless'), 'request-need-encoding-24bit');
        $this->assertNotEquals(ENCODING, $this->request->currentEncoding(), 'request-encoding-specified');

        $this->assertEquals(['MP3', 'FLAC'], $this->request->currentFormat(), 'request-cur-format');
        $this->assertEquals(['MP3', 'FLAC'], $this->request->needFormatList(), 'request-list-format');
        $this->assertEquals('MP3, FLAC', $this->request->descriptionFormat(), 'request-descr-format');
        $this->assertEquals('MP3|FLAC', $this->request->legacyFormatList(), 'request-legacy-format');
        $this->assertTrue($this->request->needFormat('FLAC'), 'request-need-format-flac');
        $this->assertFalse($this->request->needFormat('AAC'), 'request-need-format-aac');
        $this->assertNotEquals(FORMAT, $this->request->currentFormat(), 'request-format-specified');

        $this->assertEquals(['CD', 'WEB'], $this->request->currentMedia(), 'request-cur-media');
        $this->assertEquals(['CD', 'WEB'], $this->request->needMediaList(), 'request-list-media');
        $this->assertEquals('CD, WEB', $this->request->descriptionMedia(), 'request-descr-media');
        $this->assertEquals('CD|WEB', $this->request->legacyMediaList(), 'request-legacy-media');
        $this->assertTrue($this->request->needMedia('CD'), 'request-need-media-cd');
        $this->assertFalse($this->request->needMedia('DVD'), 'request-need-media-DVD');
        $this->assertNotEquals(MEDIA, $this->request->currentMedia(), 'request-media-specified');

        $this->assertTrue($this->request->canVote($admin), 'request-vote-owner');
        $this->assertTrue($this->request->canVote($user), 'request-vote-other');
        $this->assertTrue($this->request->canEditOwn($admin), 'request-edit-own-owner');
        $this->assertTrue($this->request->canEdit($admin), 'request-edit-owner');
        $this->assertFalse($this->request->canEditOwn($user), 'request-edit-own-other');
        $this->assertFalse($this->request->canEdit($user), 'request-edit-other');

        $this->assertEquals(1, $this->request->remove(), 'request-remove');
        unset($this->request); // success, no need to tidy up
        $this->assertNull($manager->findById($id), 'request-gone');
    }

    public function testRequestAny(): void {
        $this->request = Helper::makeRequestMusic(
            $this->userList['admin'],
            'phpunit request any',
            encoding: new Request\Encoding(true, []),
            format:   new Request\Format(true, []),
            media:    new Request\Media(true, []),
        );
        $this->assertEquals(
            ENCODING,
            $this->request->currentEncoding(),
            'request-any-encoding'
        );
        $this->assertEquals(
            FORMAT,
            $this->request->currentFormat(),
            'request-any-format'
        );
        $this->assertEquals(
            MEDIA,
            $this->request->currentMedia(),
            'request-any-media'
        );
    }

    public function testFillBasic(): void {
        $statsReq = new Stats\Request();
        $statsReq->flush();
        $admin  = $this->userList['admin'];
        $user   = $this->userList['user'];
        $before = [
            'created-size'  => 0,
            'created-total' => 0,
            'vote-size'     => 0,
            'vote-total'    => 0,
            'uploaded'      => $admin->flush()->uploadedSize(),
            'total'         => $statsReq->total(),
            'total-filled'  => $statsReq->filledTotal(),
        ];

        $requestMan = new Manager\Request();
        $title  = 'phpunit req fill ' . randomString(6);
        $bounty = 1024 ** 2 * REQUEST_MIN;
        $this->request = $requestMan->create(
            user:            $admin,
            bounty:          $bounty,
            categoryId:      new Manager\Category()->findIdByName('Music'),
            year:            2018,
            title:           $title,
            image:           '',
            description:     'This is a unit test description',
            recordLabel:     'Unitest Artists',
            catalogueNumber: 'UA-7890',
            releaseType:     1,
            encoding:        new Request\Encoding(list: ['Lossless', 'V0 (VBR)']),
            format:          new Request\Format(list: ['MP3', 'FLAC']),
            media:           new Request\Media(list: ['CD', 'WEB']),
            logCue:          new Request\LogCue(),
        );

        $statsReq->flush();
        $this->assertEquals($before['total'] + 1, $statsReq->total(), 'request-stats-new-total');
        $this->assertEquals($before['total-filled'], $statsReq->filledTotal(), 'request-stats-new-filled');

        $statsUser = new Stats\Users();
        $statsUser->refresh();

        $admin->flush();
        $after = [
            'created-size'  => $admin->stats()->requestCreatedSize(),
            'created-total' => $admin->stats()->requestCreatedTotal(),
            'vote-size'     => $admin->stats()->requestVoteSize(),
            'vote-total'    => $admin->stats()->requestVoteTotal(),
            'uploaded'      => $admin->uploadedSize(),
        ];

        $this->assertNull($this->request->fillerId(), 'request-unfilled-filler-id');
        $this->assertNull($this->request->torrentId(), 'request-unfilled-torrent-id');
        $this->assertNull($this->request->fillDate(), 'request-unfilled-date');

        $taxedBounty = (int)($bounty * (1 - REQUEST_TAX));
        $this->assertEquals(1, $after['created-total'], 'request-created-total');
        $this->assertEquals(1, $after['vote-total'], 'request-vote-total');
        $this->assertEquals($taxedBounty, $after['created-size'] - $before['created-size'], 'request-created-size');
        $this->assertEquals($taxedBounty, $after['vote-size'] - $before['vote-size'], 'request-vote-size');
        $this->assertEquals(-$bounty, $after['uploaded'] - $before['uploaded'], 'request-subtract-bounty');

        // If this next test fails, first try re-running the suite. There is a microsecond
        // race condition between requests.LastPostTime and requests.created that would be
        // difficult to remove without adding a lot of complications to the code.
        $this->assertFalse($this->request->hasNewVote(), 'request-no-new-vote');

        // add some bounty
        Helper::sleepTick(); // to ensure lastVoteDate() > created()
        $this->assertTrue($this->request->vote($user, $bounty), 'request-more-bounty');
        $this->assertTrue($this->request->flush()->hasNewVote(), 'request-has-new-vote');
        $this->assertEquals(2, $this->request->userVotedTotal(), 'request-total-voted');
        $this->assertEquals(2 * $taxedBounty, $this->request->bountyTotal(), 'request-total-bounty-added');
        $this->assertTrue(Helper::recentDate($this->request->lastVoteDate()), 'request-last-vote-date');
        $this->assertEquals(2, $this->request->userVotedTotal(), 'request-user-voted-total');
        $this->assertEqualsCanonicalizing(
            [$admin->id, $user->id],
            array_column($this->request->userIdVoteList(), 'user_id'),
            'request-user-id-vote-list',
        );
        $this->assertEqualsCanonicalizing(
            [$admin->id, $user->id],
            array_keys($this->request->bounty()),
            'request-bounty',
        );
        $this->assertEquals(
            $taxedBounty,
            $this->request->userBounty($admin),
            'request-user-bounty-total'
        );
        $this->assertCount(2, array_column($this->request->bounty(), 'UserID'));
        $this->assertCount(2, array_column($this->request->bounty(), 'Bounty'));

        $fillBefore = [
            'uploaded'     => $user->uploadedSize(),
            'bounty-size'  => $user->stats()->requestBountySize(),
            'bounty-total' => $user->stats()->requestBountyTotal(),
        ];

        // make a torrent to fill the request
        $tgroupName = 'phpunit request ' . randomString(6);
        $this->tgroup = Helper::makeTGroupMusic(
            name:       $tgroupName,
            artistName: [[ARTIST_MAIN], ['phpunit reqfill ' . randomString(12)]],
            tagName:    ['electronic'],
            user:       $user,
        );
        Helper::makeTorrentMusic(
            tgroup: $this->tgroup,
            user:   $user,
            title:  'Deluxe Edition',
        );
        $torrentId = current($this->tgroup->torrentIdList());
        $torMan    = new Manager\Torrent();
        $torrent   = $torMan->findById($torrentId);
        $this->assertInstanceOf(Torrent::class, $torrent, 'request-torrent-filler');

        $this->assertEquals(1, $this->request->fill($user, $torrent), 'request-fill');
        $this->assertEquals($fillBefore['bounty-size'] + $taxedBounty * 2, $user->stats()->flush()->requestBountySize(), 'request-fill-receive-bounty');
        $this->assertEquals($fillBefore['bounty-total'] + 1, $user->stats()->requestBountyTotal(), 'request-fill-receive-total');
        $this->assertTrue(Helper::recentDate($this->request->fillDate()), 'request-fill-date');
        $this->assertEquals($this->request->id, $torrent->requestFills()[0]->id, 'request-torrent-fills');

        $statsReq->flush();
        $this->assertEquals($before['total'] + 1, $statsReq->total(), 'request-stats-now-total');
        $this->assertEquals($before['total-filled'] + 1, $statsReq->filledTotal(), 'request-stats-now-filled');
        $this->assertGreaterThan(0.0, $statsReq->filledPercent(), 'request-stats-filled-percent');
        $this->assertTrue($this->request->isFilled(), 'request-now-filled');
        $this->assertEquals(
            1,
            $this->request->informRequestFillerReduction(100, $admin),
            'request-inform-bounty-reduction',
        );

        $reportManager = new Manager\Torrent\Report($torMan);
        $reportManager->create(
            torrent:     $torrent,
            user:        $user,
            reportType:  new Manager\Torrent\ReportType()->findByName('Other'),
            reason:      'phpunit requst other report',
            otherIdList: '',
            irc:         new Util\Irc(),
        );
        $reportList = $requestMan->findByTorrentReported($torrent);
        $this->assertEquals(
            [$this->request->id],
            [$reportList[0]->id],
            'req-find-by-torrent-reported'
        );

        // and now unfill it
        $this->assertEquals(
            1,
            $this->request->unfill($this->userList['admin'], 'unfill unittest'),
            'request-unfill',
        );
        $this->assertEquals(
            $fillBefore['uploaded'] - 100, // 100 from bounty reduction
            $this->userList['user']->flush()->uploadedSize(),
            'request-fill-unfill-user',
        );
        $this->assertEquals(
            $fillBefore['bounty-total'],
            $this->userList['user']->stats()->requestBountyTotal(),
            'request-fill-unfill-total',
        );
        $this->assertFalse($this->request->isFilled(), 'request-unfilled');

        $siteLog = new Manager\SiteLog();
        $page = $siteLog->page(2, 0, $this->request->title());
        $this->assertStringStartsWith(
            "Request <a href=\"{$this->request->url()}\">{$this->request->id}</a> ({$this->request->title()})",
            $page[0]['message'],
            'request-log-unfill-title'
        );
        $this->assertStringContainsString(
            "was unfilled by user {$admin->id} ({$admin->link()}) for the reason",
            $page[0]['message'],
            'request-log-unfill-by'
        );
        $this->assertStringContainsString(
            "was filled by user {$user->id} ({$user->link()}) with the torrent <a href=\"torrents.php?torrentid={$torrent->id}\">{$torrent->id}</a>",
            $page[1]['message'],
            'request-log-fill-by'
        );

        $statsReq->flush();
        $this->assertEquals(
            $before['total-filled'],
            $statsReq->filledTotal(),
            'request-stats-now-unfilled',
        );

        $this->assertEquals(
            1,
            $this->request->refundBounty($this->userList['user'], $admin),
            'request-bounty-refund',
        );
        $this->assertEquals(
            1,
            $this->request->removeBounty($admin, $admin),
            'request-bounty-remove',
        );
    }

    public function testFillLooseFit(): void {
        $this->request = Helper::makeRequestMusic(
            user:     $this->userList['admin'],
            title:    'req any fill',
            encoding: new Request\Encoding(list: []),
            format:   new Request\Format(list: []),
            media:    new Request\Media(list: []),
        );
        $this->tgroup = Helper::makeTGroupMusic(
            name:      'phpunit request ' . randomString(6),
            artistName: [[ARTIST_MAIN], ['phpunit reqloose ' . randomString(12)]],
            tagName:    ['electronic'],
            user:       $this->userList['user'],
        );
        Helper::makeTorrentMusic(
            tgroup: $this->tgroup,
            user:   $this->userList['user'],
            title:  'Deluxe Edition',
        );
        $torrent = new Manager\Torrent()->findById(
            current($this->tgroup->torrentIdList())
        );
        $this->assertEquals(
            [],
            $this->request->validate($torrent, $this->userList['user'], isAdmin: false),
            'request-any-validate',
        );
        $find = new Manager\Request()->findUnfilledByUser($this->userList['admin'], 2);
        $this->assertCount(1, $find, 'request-find-unfilled');
        $this->assertEquals($this->request->id, $find[0]->id, 'request-found');
        $this->assertEquals(
            1,
            $this->request->fill(
                $this->userList['user'],
                $torrent,
            ),
            'request-any-fill'
        );
    }

    public function testValidate(): void {
        $user = $this->userList['user'];
        $user->addBounty(BUFFER_FOR_BOUNTY);
        $user2 = Helper::makeUser('req.' . randomString(10), 'request');
        $this->userList['user2'] = $user2;

        $this->request = Helper::makeRequestMusic(
            user:     $user,
            title:    'phpunit req validate ' . randomString(6),
            encoding: new Request\Encoding(list: ['Lossless']),
            format:   new Request\Format(list: ['FLAC']),
            media:    new Request\Media(list: ['CD']),
            logCue:   new Request\LogCue(minScore: 80, needLogChecksum: true),
        );
        $this->tgroup = Helper::makeTGroupMusic(
            name:       'phpunit request validate ' . randomString(6),
            artistName: [[ARTIST_MAIN], ['phpunit reqvalidate ' . randomString(12)]],
            tagName:    ['electronic'],
            user:       $user2,
        );
        $torrent = Helper::makeTorrentMusic(
            tgroup:   $this->tgroup,
            user:     $user2,
            title:    'Deluxe Edition',
            media:    'WEB',
            format:   'MP3',
            encoding: '320',
        );

        $this->assertEquals(
            ["There is a one hour grace period for new uploads to allow the uploader ({$user2->username()}) to fill the request."],
            $this->request->validate($torrent, $user, isAdmin: false),
            'req-fill-bad-user',
        );

        $this->assertEquals(
            [
                "WEB is not an allowed media for this request.",
                "MP3 is not an allowed format for this request.",
                "320 is not an allowed encoding for this request.",
            ],
            $this->request->validate($torrent, $user2, isAdmin: false),
            'req-fill-web-mp3-320',
        );

        $torrent->setField('Encoding', 'Lossless')->setField('Format', 'FLAC')->modify();
        $this->assertEquals(
            ["WEB is not an allowed media for this request."],
            $this->request->validate($torrent, $user2, isAdmin: false),
            'req-fill-web-flac-lossless',
        );

        $torrent->setField('Media', 'CD')->modify();
        $this->assertEquals(
            [
                "This request requires a cue file.",
                "This request requires a valid logfile and none was uploaded with this torrent",

            ],
            $this->request->validate($torrent, $user2, isAdmin: false),
            'req-fill-cd-flac-lossless',
        );

        $torrent->setField('HasCue', '1')->setField('HasLogDb', '1')->modify();
        $this->assertEquals(
            ["This request requires a logfile with a valid checksum"],
            $this->request->validate($torrent, $user2, isAdmin: false),
            'req-fill-has-log-checksum',
        );

        $torrent->setField('LogChecksum', '1')->modify();
        $this->assertEquals(
            ["This request requires a logfile with a score of 80% or better"],
            $this->request->validate($torrent, $user2, isAdmin: false),
            'req-fill-has-low-score',
        );

        $torrent->setField('LogScore', 80)->modify();
        $this->assertEquals(
            [],
            $this->request->validate($torrent, $user, isAdmin: true),
            'req-fill-ok',
        );

        $this->assertEquals(
            [],
            $this->request->validate($torrent, $user, isAdmin: true),
            'req-fill-override-user',
        );

        $torrent->group()->setField('CategoryID', 2)->modify();
        $this->assertEquals(
            ["This torrent is of a different category than the request. If the request is actually miscategorized, please contact staff."],
            $this->request->validate($torrent, $user, isAdmin: true),
            'req-fill-category',
        );
        $this->request->fill($user, $torrent);

        $this->assertEquals(
            [
                "This request has already been filled.",
                "This torrent is of a different category than the request. If the request is actually miscategorized, please contact staff.",
            ],
            $this->request->validate($torrent, $user, isAdmin: true),
            'req-fill-filled',
        );
    }

    public function testVotes(): void {
        $user = $this->userList['user'];
        $user->addBounty(BUFFER_FOR_BOUNTY);
        $user2 = Helper::makeUser('req.' . randomString(10), 'request');
        $this->userList['user2'] = $user2;
        $user2->setField('Enabled', '1')->modify();
        $user2->addBounty(BUFFER_FOR_BOUNTY);

        $requestMan = new Manager\Request();
        $title  = 'phpunit req fill ' . randomString(6);
        $bounty = 1024 ** 2 * REQUEST_MIN;
        $this->request = $requestMan->create(
            user:            $user,
            bounty:          $bounty,
            categoryId:      new Manager\Category()->findIdByName('Music'),
            year:            2018,
            title:           $title,
            image:           '',
            description:     'This is a unit test description',
            recordLabel:     'Unitest Artists',
            catalogueNumber: 'UA-7890',
            releaseType:     1,
            encoding:        new Request\Encoding(list: ['Lossless', 'V0 (VBR)']),
            format:          new Request\Format(list: ['MP3', 'FLAC']),
            media:           new Request\Media(list: ['CD', 'WEB']),
            logCue:          new Request\LogCue(),
        );

        $this->request->vote($user2, $bounty + 1);
        $this->request->vote($user2, $bounty + 7);
        $this->request->vote($user, $bounty + 15);

        $votes = $this->request->voteList();
        $this->assertCount(4, $votes, 'request-votes-count');
        $first = $votes[0]['created'];
        $added = $votes[1]['created'];
        // can be 1 second later
        $this->assertLessThan(2, abs($first->getTimestamp() - $added->getTimestamp()), 'request-vote-order');
        $this->assertEquals($bounty + 15, $votes[0]['bounty'], 'request-vote-bounty1');
        $this->assertEquals($bounty + 1, $votes[2]['bounty'], 'request-vote-bounty2');
        $this->assertEquals($user->id, $votes[0]['id_user'], 'request-vote-user1');
        $this->assertEquals($user2->id, $votes[2]['id_user'], 'request-vote-user2');
    }

    public function testBookmark(): void {
        $manager = new Manager\Request();
        $this->request = $manager->create(
            user:            $this->userList['admin'],
            bounty:          1024 ** 2 * REQUEST_MIN,
            categoryId:      new Manager\Category()->findIdByName('Music'),
            year:            (int)date('Y'),
            title:           'phpunit request bookmark',
            image:           '',
            description:     'This is a unit test description',
            recordLabel:     'Unitest Artists',
            catalogueNumber: 'UA-7890',
            releaseType:     1,
            encoding:        new Request\Encoding(list: ['Lossless']),
            format:          new Request\Format(list: ['FLAC']),
            media:           new Request\Media(list: ['WEB']),
            logCue:          new Request\LogCue(),
        );
        $this->request->artistRole()->set(
            [ARTIST_MAIN => ['phpunit req ' . randomString(6)]],
            $this->userList['user'],
        );
        new Manager\Tag()->softCreate('classical.era', $this->userList['admin'])->addRequest($this->request);
        $this->assertTrue(
            new User\Bookmark($this->userList['user'])->create($this->request),
            'request-bookmark-add'
        );
    }

    public function testReport(): void {
        // FIXME: this duplicates tests in tests/phpunit/manager/ReportManagerTest.php
        $this->request = Helper::makeRequestMusic($this->userList['admin'], 'phpunit request report');
        $this->request->artistRole()->set(
            [ARTIST_MAIN => ['phpunit req ' . randomString(6)]],
            $this->userList['user'],
        );
        new Manager\Tag()
            ->create('phpunit.' . randomString(6), $this->userList['admin'])
            ->addRequest($this->request);

        $title = 'phpunit request report';
        $reportMan = new Manager\Report();
        $report = $reportMan->create(
            $this->userList['user'], $this->request->id, 'request', $title
        );

        $this->assertEquals('phpunit request report', $report->reason(), 'request-report-reason');
        $requestReport = new Report\Request($report->id, $this->request);
        $this->assertStringStartsWith('Request Report: ', $requestReport->titlePrefix(), 'request-report-title');
        $this->assertEquals('report/request.twig', $requestReport->template(), 'request-report-template');
        $this->assertEquals(
            "the request [url=requests.php?action=view&amp;id={$this->request->id}]{$title}[/url]",
            $requestReport->bbLink(),
            'request-report-bb-link'
        );

        $report->remove();
    }

    public function testJson(): void {
        $this->request = Helper::makeRequestMusic(
            $this->userList['admin'],
            'phpunit request json',
        );
        $this->request->artistRole()->set(
            [ARTIST_MAIN => ['phpunit req ' . randomString(6)]],
            $this->userList['user'],
        );
        new Manager\Tag()
            ->create('phpunit.' . randomString(6), $this->userList['admin'])
            ->addRequest($this->request);
        $this->assertInstanceOf(Request::class, $this->request, 'request-json-create');

        $json = new Json\Request(
            $this->request,
            $this->userList['user'],
            new User\Bookmark($this->userList['user']),
            new Comment\Request($this->request->id, 1, 0),
        );
        $payload = $json->payload();
        $this->assertCount(41, $payload, 'req-json-payload');
        $this->assertTrue($payload['canVote'], 'req-json-can-vote');
        $this->assertFalse($payload['canEdit'], 'req-json-can-edit');

        $added = new \DateTime($payload['timeAdded']);
        $voted = new \DateTime($payload['lastVote']);
        // can be 1 second later
        $this->assertLessThan(2, abs($voted->getTimestamp() - $added->getTimestamp()), 'req-json-date');
        $this->assertEquals('', $payload['fillerName'], 'req-json-can-vote');
        $this->assertEquals('UA-7890', $payload['catalogueNumber'], 'req-json-catno');
        $this->assertEquals(['Lossless', 'V0 (VBR)'], $payload['bitrateList'], 'req-json-bitrate-list');
        $this->assertEquals(['MP3', 'FLAC'], $payload['formatList'], 'req-json-format-list');
        $this->assertEquals(['CD', 'WEB'], $payload['mediaList'], 'req-json-media-list');
        $this->assertTrue($payload['needCue'], 'req-json-needlog');
        $this->assertTrue($payload['needLog'], 'req-json-needcue');
        $this->assertTrue($payload['needLogChecksum'], 'req-json-needlogchecksum');
        $this->assertEquals(100, $payload['minLogScore'], 'req-json-minlogscore');

        $encoding = $this->request->encoding();
        $this->assertTrue($encoding->isValid(), 'req-enc-valid');
        $this->assertFalse($encoding->all(), 'req-enc-all');
        $this->assertFalse($encoding->exists('320'), 'req-enc-no-enc');
        $this->assertTrue($encoding->exists('Lossless'), 'req-enc-enc');

        $format = $this->request->format();
        $this->assertTrue($format->isValid(), 'req-for-valid');
        $this->assertFalse($format->all(), 'req-for-all');
        $this->assertTrue($format->exists('MP3'), 'req-for-no-for');
        $this->assertTrue($format->exists('FLAC'), 'req-for-for');

        $media = $this->request->media();
        $this->assertTrue($media->isValid(), 'req-med-valid');
        $this->assertFalse($media->all(), 'req-med-all');
        $this->assertFalse($media->exists('Vinyl'), 'req-med-no-med');
        $this->assertTrue($media->exists('WEB'), 'req-med-med');
    }

    public function testEncodingValue(): void {
        $allEncoding = new Request\Encoding();
        $this->assertTrue($allEncoding->isValid(), 'req-enc-all-invalid');
        $this->assertTrue($allEncoding->exists('Lossless'), 'req-enc-invalid-exists');

        $allEncoding = new Request\Encoding(true);
        $this->assertTrue($allEncoding->isValid(), 'req-enc-all-valid');
        $this->assertTrue($allEncoding->exists('Lossless'), 'req-enc-all-flac');
        $this->assertTrue($allEncoding->exists('Morse'), 'req-enc-all-morse'); // because of all encodings shortcut
        $this->assertEquals('{}', $allEncoding->dbValue(), 'req-enc-all-value');

        $some = new Request\Encoding(false, ['24bit Lossless', 'V0 (VBR)']);
        $this->assertTrue($some->isValid(), 'req-enc-some-valid');
        $this->assertTrue($some->exists('24bit Lossless'), 'req-enc-some-lossless');
        $this->assertFalse($some->exists('Morse'), 'req-enc-some-morse');
        $this->assertEquals(
            '{"24bit Lossless","V0 (VBR)"}',
            $some->dbValue(),
            'req-enc-some-value'
        );
    }

    public function testFormatValue(): void {
        $allFormat = new Request\Format();
        $this->assertTrue($allFormat->isValid(), 'req-fmt-all-invalid');
        $this->assertTrue($allFormat->exists('MP3'), 'req-fmt-invalid-exists');

        $allFormat = new Request\Format(true);
        $this->assertTrue($allFormat->isValid(), 'req-fmt-all-valid');
        $this->assertTrue($allFormat->exists('FLAC'), 'req-fmt-all-flac');
        $this->assertEquals('{}', $allFormat->dbValue(), 'req-fmt-all-value');

        $some = new Request\Format(false, ['FLAC', 'MP3']);
        $this->assertTrue($some->isValid(), 'req-fmt-some-valid');
        $this->assertTrue($some->exists('FLAC'), 'req-fmt-some-flac');
        $this->assertEquals('{"MP3","FLAC"}', $some->dbValue(), 'req-fmt-some-value');

        $also = new Request\Format(false, ['FLAC', 'MP3']);
        $this->assertEquals('{"MP3","FLAC"}', $also->dbValue(), 'req-fmt-same-value');
    }

    public function testMediaValue(): void {
        $allMedia = new Request\Media();
        $this->assertTrue($allMedia->isValid(), 'req-med-all-invalid');
        $this->assertTrue($allMedia->exists('BD'), 'req-med-invalid-exists');

        $allMedia = new Request\Media(true);
        $this->assertTrue($allMedia->isValid(), 'req-med-all-valid');
        $this->assertTrue($allMedia->exists('CD'), 'req-med-all-cd');
        $this->assertEquals('{}', $allMedia->dbValue(), 'req-med-all-value');

        $some = new Request\Media(false, ['Cassette', 'CD', 'WEB', 'Vinyl']);
        $this->assertTrue($some->isValid(), 'req-med-some-valid');
        $this->assertTrue($some->exists('Vinyl'), 'req-med-some-vinyl');
        $this->assertEquals(
            '{"CD","WEB","Vinyl","Cassette"}',
            $some->dbValue(),
            'req-med-some-value',
        );
    }

    public function testLogCueValue(): void {
        $none = new Request\LogCue();
        $this->assertTrue($none->isValid(), 'req-none-valid');
        $this->assertEquals(100, $none->minScore, 'req-none-min-score');
        $this->assertTrue($none->needLogChecksum, 'req-none-need-checksum');
        $this->assertTrue($none->needCue, 'req-none-need-cue');
        $this->assertTrue($none->needLog, 'req-none-need-log');
        $this->assertEquals('Log (100%) + Cue', $none->dbValue(), 'req-none-value');

        $cksum = new Request\LogCue(needLogChecksum: false);
        $this->assertTrue($cksum->isValid(), 'req-cksum-valid');
        $this->assertFalse($cksum->needLogChecksum, 'req-cksum-need');

        $cue = new Request\LogCue(needCue: false);
        $this->assertTrue($cue->isValid(), 'req-cue-valid');
        $this->assertEquals('Log (100%)', $cue->dbValue(), 'req-cue-value');

        $log = new Request\LogCue(needLog: false);
        $this->assertTrue($log->isValid(), 'req-log-valid');
        $this->assertEquals('Cue', $log->dbValue(), 'req-log-value');

        $logcue = new Request\LogCue(needCue: false, needLog: false);
        $this->assertTrue($logcue->isValid(), 'req-log-cue-valid');
        $this->assertEquals('', $logcue->dbValue(), 'req-log-cue-value');

        $logmin = new Request\LogCue(minScore: 50);
        $this->assertTrue($logmin->isValid(), 'req-log-min-valid');
        $this->assertEquals(50, $logmin->minScore, 'req-log-min-min-score');
        $this->assertTrue($logmin->needCue, 'req-log-min-need-cue');
        $this->assertTrue($logmin->needLog, 'req-log-min-need-log');
        $this->assertEquals('Log (>= 50%) + Cue', $logmin->dbValue(), 'req-log-min-value');

        $logmax = new Request\LogCue();
        $this->assertTrue($logmax->isValid(), 'req-log-max-valid');
        $this->assertEquals('Log (100%) + Cue', $logmax->dbValue(), 'req-log-max-value');

        $over = new Request\LogCue(needCue: true, needLog: true, minScore: 101);
        $this->assertFalse($over->isValid(), 'req-log-score-over');

        $under = new Request\LogCue(needCue: true, needLog: true, minScore: -1);
        $this->assertFalse($under->isValid(), 'req-log-score-under');
    }

    public function testRenderRequest(): void {
        $this->tgroup = Helper::makeTGroupMusic(
            name       : 'phpunit render req',
            artistName : [[ARTIST_MAIN], ['phpunit render req ' . randomString(12)]],
            tagName    : ['reggae'],
            user       : $this->userList['user'],
        );
        $this->request = Helper::makeRequestMusic($this->userList['admin'], 'phpunit render req');
        $this->request->setField('id_tgroup', $this->tgroup->id)->modify();

        $this->assertStringContainsString(
            "<span style=\"font-weight: bold;\">Requests (1)</span>",
            Util\Twig::factory(new Manager\User())->render('request/torrent.twig', [
                'list' => new Manager\Request()->findByTGroup($this->tgroup),
            ]),
            'render-tgroup-request-list',
        );
    }

    public function testRequestFTS(): void {
        $user  = $this->userList['admin'];
        $title = 'phpunit reqfts ' . randomString(6);
        $this->request = Helper::makeRequestMusic($user, $title);
        $artistName    = 'phpunit ftsreq ' . randomString(6);
        $this->request->artistRole()->set([ARTIST_MAIN => [$artistName]], $user);

        $this->assertEquals(
            $this->request->id,
            $this->pg()->scalarex("
                select id_request
                from request
                where id_request = $1
                ", $this->request->id
            ),
            'request-fts-id', // ensure the request has been relayed
        );
        $this->assertEquals(
            $this->request->id,
            $this->pg()->scalarex("
                select id_request
                from request
                where artist_title_ts @@ websearch_to_tsquery('simple', $1)
                ", "\"{$artistName}\""
            ),
            'request-fts-search-artist'
        );
        $this->assertEquals(
            $this->request->id,
            $this->pg()->scalarex("
                select id_request
                from request
                where artist_title_ts @@ websearch_to_tsquery('simple', $1)
                ", "\"{$title}\""
            ),
            'request-fts-search-title'
        );
    }

    public function testRequestJson(): void {
        $this->request = Helper::makeRequestMusic(
            $this->userList['admin'],
            'phpunit json ' . randomString()
        );
        $payload = new Json\Requests(
                new Search\Request(),
                1,
            )->payload();
        $this->assertEqualsCanonicalizing(
            [
                'currentPage',
                'pages',
                'results',
            ],
            array_keys($payload),
            'request-json-payload',
        );
        $this->assertGreaterThan(
            0,
            count($payload['results']),
            'request-json-total',
        );
        $this->assertEquals(
            $this->request->id,
            $payload['results'][0]['requestId'],
            'request-json-id',
        );
    }

    public function testRequestSearchComment(): void {
        /**
         * Strategy:
         *  - u1 creates a request
         *  - u2 votes on it
         */
        $manager = new Manager\Collage();
        $creator = $this->userList['admin'];
        $voter   = $this->userList['user'];
        $this->request = Helper::makeRequestMusic(
            $creator,
            'phpunit comment ' . randomString()
        );
        $body    = "phpunit u{$creator->id} r{$this->request->id}";
        $comment = new Manager\Comment()->create(
            $creator,
            CommentType::request->value,
            $this->request->id,
            $body,
        );

        $searchCreator = new Search\Comment(
            CommentType::request,
            'default',
            $creator->id === $creator->id,
            $creator,
        );
        $this->assertEquals(
            1,
            $searchCreator->total(),
            'comment-request-creator-total',
        );
        $this->assertEquals(
            'Request comments',
            $searchCreator->title(),
            'comment-request-creator-title',
        );

        $this->assertEqualsCanonicalizing(
            [
                "Comments on requests you created",
                "Comments on requests you voted on",
            ],
            array_map(
                fn ($t) => $t['title'],
                $searchCreator->linkList(),
            ),
            'comment-request-creator-linklist',
        );
        $page = $searchCreator->page(2, 0);
        $this->assertCount(1, $page['list'], 'comment-request-creator-created-list-total');
        $this->assertCount(1, $page['user'], 'comment-request-creator-created-user-total');
        $this->assertCount(1, $page['request'], 'comment-request-creator-created-request-total');
        $this->assertTrue(
            isset($page['request'][$this->request->id]),
            'comment-request-creator-request-id',
        );
        $this->assertTrue(
            isset($page['user'][$creator->id]),
            'comment-request-creator-created-id',
        );
        $comment = $page['list'][0];
        $this->assertEquals($body, $comment['body'], 'comment-request-writer-body');
        $this->assertEquals(
            $this->request->id,
            $comment['id_type'],
            'comment-request-writer-request-id',
        );
        $this->assertEquals(
            $creator->id,
            $comment['id_user'],
            'comment-request-writer-user-id',
        );

        $searchCreated = new Search\Comment(
            CommentType::request,
            'created',
            $creator->id !== $creator->id,
            $creator,
        );
        $this->assertEquals(
            0,
            $searchCreated->total(),
            'comment-request-created-total',
        );
        $this->assertEquals(
            'Comments on requests they created',
            $searchCreated->title(),
            'comment-request-created-title',
        );
        $this->assertEqualsCanonicalizing(
            [
                "Request comments",
                "Comments on requests they voted on",
            ],
            array_map(
                fn ($t) => $t['title'],
                $searchCreated->linkList(),
            ),
            'comment-request-created-linklist',
        );

        $this->request->vote($voter, 1024 * 1024);
        $body    = "phpunit v{$voter->id} r{$this->request->id}";
        $comment = new Manager\Comment()->create(
            $voter,
            CommentType::request->value,
            $this->request->id,
            $body,
        );
        $searchVoter = new Search\Comment(
            CommentType::request,
            'voted',
            $voter->id === $voter->id,
            $voter,
        );
        $this->assertEquals(
            1,
            $searchVoter->total(),
            'comment-request-vote-total',
        );
        $this->assertEquals(
            'Comments on requests you voted on',
            $searchVoter->title(),
            'comment-request-vote-title',
        );
        $this->assertEqualsCanonicalizing(
            [
                "Request comments",
                "Comments on requests you created",
            ],
            array_map(
                fn ($t) => $t['title'],
                $searchVoter->linkList(),
            ),
            'comment-request-vote-linklist',
        );
    }

    public function testRequestAbort(): void {
        $this->userList['admin']->setField('leech_upload', 0)->modify();
        $this->expectException(\RangeException::class);
        $this->request = Helper::makeRequestMusic(
            $this->userList['admin'],
            'phpunit request abort',
        );
    }
}