<?php

namespace PhpOffice\PhpSpreadsheet\Writer;

use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Spreadsheet;

class Csv extends BaseWriter
{
    /**
     * PhpSpreadsheet object.
     *
     * @var Spreadsheet
     */
    private $spreadsheet;

    /**
     * Delimiter.
     *
     * @var string
     */
    private $delimiter = ',';

    /**
     * Enclosure.
     *
     * @var string
     */
    private $enclosure = '"';

    /**
     * Line ending.
     *
     * @var string
     */
    private $lineEnding = PHP_EOL;

    /**
     * Sheet index to write.
     *
     * @var int
     */
    private $sheetIndex = 0;

    /**

<      * Whether to write a BOM (for UTF8).



>      * Whether to write a UTF8 BOM.


     *
     * @var bool
     */
    private $useBOM = false;

    /**
     * Whether to write a Separator line as the first line of the file
     *     sep=x.
     *
     * @var bool
     */
    private $includeSeparatorLine = false;

    /**
     * Whether to write a fully Excel compatible CSV file.
     *
     * @var bool
     */
    private $excelCompatibility = false;

    /**

<      * Create a new CSV.



>      * Output encoding.


     *

<      * @param Spreadsheet $spreadsheet Spreadsheet object



>      * @var string
>      */
>     private $outputEncoding = '';
> 
>     /**
>      * Create a new CSV.


     */
    public function __construct(Spreadsheet $spreadsheet)
    {
        $this->spreadsheet = $spreadsheet;
    }

    /**
     * Save PhpSpreadsheet to file.
     *

<      * @param string $pFilename
<      *
<      * @throws Exception



>      * @param resource|string $filename


     */

<     public function save($pFilename)



>     public function save($filename, int $flags = 0): void


    {

>         $this->processFlags($flags);
        // Fetch sheet
> 


        $sheet = $this->spreadsheet->getSheet($this->sheetIndex);

        $saveDebugLog = Calculation::getInstance($this->spreadsheet)->getDebugLog()->getWriteDebugLog();
        Calculation::getInstance($this->spreadsheet)->getDebugLog()->setWriteDebugLog(false);
        $saveArrayReturnType = Calculation::getArrayReturnType();
        Calculation::setArrayReturnType(Calculation::RETURN_ARRAY_AS_VALUE);

        // Open file

<         $fileHandle = fopen($pFilename, 'wb+');
<         if ($fileHandle === false) {
<             throw new Exception("Could not open file $pFilename for writing.");
<         }



>         $this->openFileHandle($filename);



        if ($this->excelCompatibility) {
            $this->setUseBOM(true); //  Enforce UTF-8 BOM Header
            $this->setIncludeSeparatorLine(true); //  Set separator line
            $this->setEnclosure('"'); //  Set enclosure to "
            $this->setDelimiter(';'); //  Set delimiter to a semi-colon
            $this->setLineEnding("\r\n");
        }

> 


        if ($this->useBOM) {
            // Write the UTF-8 BOM code if required

<             fwrite($fileHandle, "\xEF\xBB\xBF");



>             fwrite($this->fileHandle, "\xEF\xBB\xBF");


        }

> 


        if ($this->includeSeparatorLine) {
            // Write the separator line if required

<             fwrite($fileHandle, 'sep=' . $this->getDelimiter() . $this->lineEnding);



>             fwrite($this->fileHandle, 'sep=' . $this->getDelimiter() . $this->lineEnding);


        }

        //    Identify the range that we need to extract from the worksheet
        $maxCol = $sheet->getHighestDataColumn();
        $maxRow = $sheet->getHighestDataRow();

        // Write rows to file
        for ($row = 1; $row <= $maxRow; ++$row) {
            // Convert the row to an array...
            $cellsArray = $sheet->rangeToArray('A' . $row . ':' . $maxCol . $row, '', $this->preCalculateFormulas);
            // ... and write to the file

<             $this->writeLine($fileHandle, $cellsArray[0]);



>             $this->writeLine($this->fileHandle, $cellsArray[0]);


        }


<         // Close file
<         fclose($fileHandle);
< 



>         $this->maybeCloseFileHandle();


        Calculation::setArrayReturnType($saveArrayReturnType);
        Calculation::getInstance($this->spreadsheet)->getDebugLog()->setWriteDebugLog($saveDebugLog);
    }


<     /**
<      * Get delimiter.
<      *
<      * @return string
<      */
<     public function getDelimiter()



>     public function getDelimiter(): string


    {
        return $this->delimiter;
    }


<     /**
<      * Set delimiter.
<      *
<      * @param string $pValue Delimiter, defaults to ','
<      *
<      * @return CSV
<      */
<     public function setDelimiter($pValue)



>     public function setDelimiter(string $delimiter): self


    {

<         $this->delimiter = $pValue;



>         $this->delimiter = $delimiter;



        return $this;
    }


<     /**
<      * Get enclosure.
<      *
<      * @return string
<      */
<     public function getEnclosure()



>     public function getEnclosure(): string


    {
        return $this->enclosure;
    }


<     /**
<      * Set enclosure.
<      *
<      * @param string $pValue Enclosure, defaults to "
<      *
<      * @return CSV
<      */
<     public function setEnclosure($pValue)



>     public function setEnclosure(string $enclosure = '"'): self


    {

<         if ($pValue == '') {
<             $pValue = null;
<         }
<         $this->enclosure = $pValue;



>         $this->enclosure = $enclosure;



        return $this;
    }


<     /**
<      * Get line ending.
<      *
<      * @return string
<      */
<     public function getLineEnding()



>     public function getLineEnding(): string


    {
        return $this->lineEnding;
    }


<     /**
<      * Set line ending.
<      *
<      * @param string $pValue Line ending, defaults to OS line ending (PHP_EOL)
<      *
<      * @return CSV
<      */
<     public function setLineEnding($pValue)



>     public function setLineEnding(string $lineEnding): self


    {

<         $this->lineEnding = $pValue;



>         $this->lineEnding = $lineEnding;



        return $this;
    }

    /**
     * Get whether BOM should be used.

<      *
<      * @return bool


     */

<     public function getUseBOM()



>     public function getUseBOM(): bool


    {
        return $this->useBOM;
    }

    /**

<      * Set whether BOM should be used.
<      *
<      * @param bool $pValue Use UTF-8 byte-order mark? Defaults to false
<      *
<      * @return CSV



>      * Set whether BOM should be used, typically when non-ASCII characters are used.


     */

<     public function setUseBOM($pValue)



>     public function setUseBOM(bool $useBOM): self


    {

<         $this->useBOM = $pValue;



>         $this->useBOM = $useBOM;



        return $this;
    }

    /**
     * Get whether a separator line should be included.

<      *
<      * @return bool


     */

<     public function getIncludeSeparatorLine()



>     public function getIncludeSeparatorLine(): bool


    {
        return $this->includeSeparatorLine;
    }

    /**
     * Set whether a separator line should be included as the first line of the file.

<      *
<      * @param bool $pValue Use separator line? Defaults to false
<      *
<      * @return CSV


     */

<     public function setIncludeSeparatorLine($pValue)



>     public function setIncludeSeparatorLine(bool $includeSeparatorLine): self


    {

<         $this->includeSeparatorLine = $pValue;



>         $this->includeSeparatorLine = $includeSeparatorLine;



        return $this;
    }

    /**
     * Get whether the file should be saved with full Excel Compatibility.

<      *
<      * @return bool


     */

<     public function getExcelCompatibility()



>     public function getExcelCompatibility(): bool


    {
        return $this->excelCompatibility;
    }

    /**
     * Set whether the file should be saved with full Excel Compatibility.
     *

<      * @param bool $pValue Set the file to be written as a fully Excel compatible csv file



>      * @param bool $excelCompatibility Set the file to be written as a fully Excel compatible csv file


     *                                Note that this overrides other settings such as useBOM, enclosure and delimiter

<      *
<      * @return CSV


     */

<     public function setExcelCompatibility($pValue)



>     public function setExcelCompatibility(bool $excelCompatibility): self


    {

<         $this->excelCompatibility = $pValue;



>         $this->excelCompatibility = $excelCompatibility;



        return $this;
    }


<     /**
<      * Get sheet index.
<      *
<      * @return int
<      */
<     public function getSheetIndex()



>     public function getSheetIndex(): int


    {
        return $this->sheetIndex;
    }


>     public function setSheetIndex(int $sheetIndex): self
    /**
>     {
     * Set sheet index.
>         $this->sheetIndex = $sheetIndex;
     *
> 
     * @param int $pValue Sheet index
>         return $this;
     *
>     }
     * @return CSV
> 
     */
>     public function getOutputEncoding(): string
    public function setSheetIndex($pValue)
>     {
    {
>         return $this->outputEncoding;
        $this->sheetIndex = $pValue;
>     }

> 
        return $this;
>     public function setOutputEncoding(string $outputEnconding): self
    }
>     {

>         $this->outputEncoding = $outputEnconding;
    /**
> 
     * Write line to CSV file.
>         return $this;
     *
>     }
     * @param resource $pFileHandle PHP filehandle
> 
     * @param array $pValues Array containing values in a row
>     /** @var bool */
     */
>     private $enclosureRequired = true;
    private function writeLine($pFileHandle, array $pValues)
> 
    {
>     public function setEnclosureRequired(bool $value): self
        // No leading delimiter
>     {
        $writeDelimiter = false;
>         $this->enclosureRequired = $value;

> 
        // Build the line
>         return $this;
        $line = '';
>     }

> 
        foreach ($pValues as $element) {
>     public function getEnclosureRequired(): bool
            // Escape enclosures
>     {
            $element = str_replace($this->enclosure, $this->enclosure . $this->enclosure, $element);
>         return $this->enclosureRequired;

>     }
            // Add delimiter
> 



<      * Set sheet index.



>      * Convert boolean to TRUE/FALSE; otherwise return element cast to string.



<      * @param int $pValue Sheet index
<      *
<      * @return CSV



>      * @param mixed $element



<     public function setSheetIndex($pValue)



>     private static function elementToString($element): string



<         $this->sheetIndex = $pValue;



>         if (is_bool($element)) {
>             return $element ? 'TRUE' : 'FALSE';
>         }



<         return $this;



>         return (string) $element;



<      * @param resource $pFileHandle PHP filehandle
<      * @param array $pValues Array containing values in a row



>      * @param resource $fileHandle PHP filehandle
>      * @param array $values Array containing values in a row



<     private function writeLine($pFileHandle, array $pValues)



>     private function writeLine($fileHandle, array $values): void



<         $writeDelimiter = false;



>         $delimiter = '';



<         foreach ($pValues as $element) {
<             // Escape enclosures
<             $element = str_replace($this->enclosure, $this->enclosure . $this->enclosure, $element);
< 



>         foreach ($values as $element) {
>             $element = self::elementToString($element);



<             if ($writeDelimiter) {
<                 $line .= $this->delimiter;



>             $line .= $delimiter;
>             $delimiter = $this->delimiter;
>             // Escape enclosures
>             $enclosure = $this->enclosure;
>             if ($enclosure) {
>                 // If enclosure is not required, use enclosure only if
>                 // element contains newline, delimiter, or enclosure.
>                 if (!$this->enclosureRequired && strpbrk($element, "$delimiter$enclosure\n") === false) {
>                     $enclosure = '';



<                 $writeDelimiter = true;



>                     $element = str_replace($enclosure, $enclosure . $enclosure, $element);
>                 }



< 



<             $line .= $this->enclosure . $element . $this->enclosure;



>             $line .= $enclosure . $element . $enclosure;



<         fwrite($pFileHandle, $line);



>         if ($this->outputEncoding != '') {
>             $line = mb_convert_encoding($line, $this->outputEncoding);
>         }
>         fwrite($fileHandle, /** @scrutinizer ignore-type */ $line);