/*
 * libfud
 * Copyright 2025 Dominick Allen
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "fud_csv.hpp"

namespace fud {

FudStatus Csv::parseCsvFromFilename(
    Csv& csv,
    Option<TextBuffer&&> bufferOption,
    StringView filename,
    OpenFlags flags,
    Option<int> dirFdOption)
{
    auto fileResult{RegularFile::open(filename, FileAccessMode::Read, flags, dirFdOption)};

    if (fileResult.isError()) {
        return fileResult.takeError();
    }

    if (bufferOption.hasValue()) {
        auto bufferedFile{BufferedRegularFile::make(fileResult.takeOkay(), std::move(bufferOption.value()))};
        return parseCsvFromBufferedFile(csv, bufferedFile);
    }

    auto unbufferedFile{fileResult.takeOkay()};
    return parseCsvFromUnbufferedFile(csv, std::move(unbufferedFile));
}

enum class CsvTextState : uint8_t
{
    UnquotedField,
    QuotedField,
    Separator,
    Newline,
};

FudStatus Csv::parseCsvFromBufferedFile(Csv& csv, BufferedRegularFile& file)
{
    auto lineEnding{newlineText(csv.newlineDelimiter)};
    static_cast<void>(lineEnding);
    DrainResult readResult{};
    while (true) {
        utf8 letter{};
        auto drainResult = file.read(reinterpret_cast<std::byte*>(&letter), sizeof(letter), NullOpt);
        readResult.status = drainResult.status;
        readResult.bytesDrained += drainResult.bytesDrained;
        // if (status
        // REMOVE
        break;
    }

    size_t rawSize = 0;

    while (true) {
        rawSize++;
        // REMOVE
        break;
    }

    auto reserveStatus = csv.buffer.reserve(rawSize);
    if (reserveStatus != FudStatus::Success) {
        return reserveStatus;
    }

    return FudStatus::NotImplemented;
}

FudStatus Csv::parseCsvFromUnbufferedFile(Csv& csv, RegularFile&& file)
{
    static_cast<void>(csv);
    constexpr size_t BufferSize = 256;
    SimpleStackAllocator<BufferSize> stackAllocator{};
    auto bufferedFile{BufferedRegularFile::make(std::move(file), TextBuffer{stackAllocator})};
    return parseCsvFromBufferedFile(csv, bufferedFile);
}

} // namespace fud