<?php

declare(strict_types=1);

namespace PhpOffice\PhpSpreadsheetTests\Reader\Csv;

use PhpOffice\PhpSpreadsheet\Reader\Csv;
use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;

class CsvTest extends TestCase
{
    #[DataProvider('providerDelimiterDetection')]
    public function testDelimiterDetection(string $filename, string $expectedDelimiter, string $cell, string|float|int|null $expectedValue): void
    {
        $reader = new Csv();
        $delim1 = $reader->getDelimiter();
        self::assertNull($delim1);

        $spreadsheet = $reader->load($filename);

        self::assertSame($expectedDelimiter, $reader->getDelimiter(), 'should be able to infer the delimiter');

        $actual = $spreadsheet->getActiveSheet()->getCell($cell)->getValue();
        self::assertSame($expectedValue, $actual, 'should be able to retrieve correct value');
        $spreadsheet->disconnectWorksheets();
    }

    public static function providerDelimiterDetection(): array
    {
        return [
            [
                'tests/data/Reader/CSV/enclosure.csv',
                ',',
                'C4',
                'username2',
            ],
            [
                'tests/data/Reader/CSV/semicolon_separated.csv',
                ';',
                'C2',
                '25,5',
            ],
            [
                'tests/data/Reader/CSV/line_break_in_enclosure.csv',
                ',',
                'A3',
                'Test',
            ],
            [
                'tests/data/Reader/CSV/line_break_in_enclosure_with_escaped_quotes.csv',
                ',',
                'A3',
                'Test',
            ],
            [
                'tests/data/Reader/HTML/csv_with_angle_bracket.csv',
                ',',
                'B1',
                'Number of items with weight <= 50kg',
            ],
            [
                'samples/Reader2/sampleData/example1.csv',
                ',',
                'I4',
                '100%',
            ],
            [
                'samples/Reader2/sampleData/example2.csv',
                ',',
                'D8',
                -58.373161,
            ],
            [
                'tests/data/Reader/CSV/empty.csv',
                ',',
                'A1',
                null,
            ],
            [
                'tests/data/Reader/CSV/no_delimiter.csv',
                ',',
                'A1',
                'SingleLine',
            ],
        ];
    }

    #[DataProvider('providerCanLoad')]
    public function testCanLoad(bool $expected, string $filename): void
    {
        $reader = new Csv();
        self::assertSame($expected, $reader->canRead($filename));
    }

    public static function providerCanLoad(): array
    {
        return [
            [false, 'tests/data/Reader/Ods/data.ods'],
            [false, 'samples/templates/excel2003.xml'],
            [true, 'tests/data/Reader/CSV/enclosure.csv'],
            [true, 'tests/data/Reader/CSV/semicolon_separated.csv'],
            [true, 'tests/data/Reader/CSV/contains_html.csv'],
            [true, 'tests/data/Reader/CSV/csv_without_extension'],
            [true, 'tests/data/Reader/HTML/csv_with_angle_bracket.csv'],
            [true, 'tests/data/Reader/CSV/empty.csv'],
            [true, 'samples/Reader2/sampleData/example1.csv'],
            [true, 'samples/Reader2/sampleData/example2.csv'],
        ];
    }

    #[DataProvider('providerVersion')]
    public function testEscapeCharacters(int $version): void
    {
        if ($version >= 90000) {
            $this->expectException(ReaderException::class);
            $this->expectExceptionMessage('Escape character must be null string');
        }
        $reader = new Csv();
        if ($version === PHP_VERSION_ID) {
            $reader->setEscapeCharacter('"');
        } else {
            $reader->setEscapeCharacter('"', $version);
        }
        $spreadsheet = $reader->load('tests/data/Reader/CSV/backslash.csv');
        $worksheet = $spreadsheet->getActiveSheet();

        $expected = [
            ['field 1', 'field 2\\'],
            ['field 3\\', 'field 4'],
        ];

        self::assertSame('"', $reader->getEscapeCharacter());
        self::assertSame($expected, $worksheet->toArray());
        $spreadsheet->disconnectWorksheets();
    }

    public static function providerVersion(): array
    {
        return [
            [PHP_VERSION_ID],
            [90000],
        ];
    }

    public function testInvalidWorkSheetInfo(): void
    {
        $this->expectException(ReaderException::class);
        $this->expectExceptionMessage('is an Invalid Spreadsheet file');
        $reader = new Csv();
        $reader->listWorksheetInfo('');
    }

    public function testLineBreakEscape(): void
    {
        $reader = new Csv();
        $spreadsheet = $reader->load('tests/data/Reader/CSV/line_break_in_enclosure_with_escaped_quotes.csv');
        $sheet = $spreadsheet->getActiveSheet();
        $expected = <<<EOF
            This is a "test csv file"
            with both "line breaks"
            and "escaped
            quotes" that breaks
            the delimiters
            EOF;
        self::assertSame($expected, $sheet->getCell('B3')->getValue());
        $spreadsheet->disconnectWorksheets();
    }

    public function testSeparatorLine(): void
    {
        $reader = new Csv();
        $reader->setSheetIndex(3);
        $spreadsheet = $reader->load('tests/data/Reader/CSV/sep.csv');
        self::assertSame(';', $reader->getDelimiter());
        $sheet = $spreadsheet->getActiveSheet();
        self::assertSame(3, $reader->getSheetIndex());
        self::assertSame(3, $spreadsheet->getActiveSheetIndex());
        self::assertSame('A', $sheet->getCell('A1')->getValue());
        self::assertSame(1, $sheet->getCell('B1')->getValue());
        self::assertSame(2, $sheet->getCell('A2')->getValue());
        self::assertSame(3, $sheet->getCell('B2')->getValue());
        $spreadsheet->disconnectWorksheets();
    }

    public function testDefaultSettings(): void
    {
        $reader = new Csv();
        self::assertSame('UTF-8', $reader->getInputEncoding());
        self::assertSame('"', $reader->getEnclosure());
        $reader->setEnclosure('\'');
        self::assertSame('\'', $reader->getEnclosure());
        $reader->setEnclosure('');
        self::assertSame('"', $reader->getEnclosure());
        // following tests from BaseReader
        self::assertTrue($reader->getReadEmptyCells());
        self::assertFalse($reader->getIncludeCharts());
        self::assertNull($reader->getLoadSheetsOnly());
    }

    public function testReadEmptyFileName(): void
    {
        $this->expectException(ReaderException::class);
        $this->expectExceptionMessage('is an Invalid Spreadsheet file');
        $reader = new Csv();
        $filename = '';
        $reader->load($filename);
    }

    public function testReadNonexistentFileName(): void
    {
        $this->expectException(ReaderException::class);
        $this->expectExceptionMessage('is an Invalid Spreadsheet file');
        $reader = new Csv();
        $reader->load('tests/data/Reader/CSV/encoding.utf8.csvxxx');
    }

    #[DataProvider('providerEscapes')]
    public function testInferSeparator(string $escape, string $delimiter, int $version = PHP_VERSION_ID): void
    {
        if ($version >= 90000 && $escape !== '') {
            $this->expectException(ReaderException::class);
            $this->expectExceptionMessage('Escape character must be null string');
        }
        $reader = new Csv();
        if ($version === PHP_VERSION_ID) {
            $reader->setEscapeCharacter($escape);
        } else {
            $reader->setEscapeCharacter($escape, $version);
        }
        $filename = 'tests/data/Reader/CSV/escape.csv';
        $reader->listWorksheetInfo($filename);
        self::assertSame($delimiter, $reader->getDelimiter());
    }

    public static function providerEscapes(): array
    {
        return [
            ['\\', ';'],
            ["\x0", ','],
            ['', ','],
            ['\\', ';', 90000],
        ];
    }

    public function testSetDelimiterNull(): void
    {
        $reader = new Csv();
        $reader->setDelimiter(',');
        self::assertSame(',', $reader->getDelimiter());
        $reader->setDelimiter(null);
        self::assertNull($reader->getDelimiter());
    }
}