/*
 * libfud
 * Copyright 2024 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 "test_common.hpp"

#include "fud_string.hpp"

#include <cstdlib>
#include <ftw.h>
#include <gtest/gtest.h>

namespace fud {

std::byte* MockFudAlloc::operator()(size_t size)
{
    return static_cast<std::byte*>(malloc(size));
}

void MockFudDealloc::operator()(std::byte* pointer)
{
    return free(pointer);
}

MockFudAlloc globalDefaultMockAlloc{};

MockFudDealloc globalDefaultMockDealloc{};

std::byte* MockFudAllocator::allocate(size_t size)
{
    return (*m_allocator)(size);
}

void MockFudAllocator::deallocate(std::byte* pointer)
{
    return (*m_deallocator)(pointer);
}

MockFudAllocator globalMockFudAlloc{};

std::byte* fudAlloc(size_t size)
{
    return globalMockFudAlloc.allocate(size);
}

void fudFree(std::byte* ptr)
{
    return globalMockFudAlloc.deallocate(ptr);
}

int unlink_cb(const char* fpath, const struct stat* sb_unused, int typeflag, struct FTW* ftwbuf)
{
    static_cast<void>(sb_unused);
    int retValue = remove(fpath);

    EXPECT_EQ(retValue, 0);
    if (retValue != 0) {
        perror(fpath);
    }

    return retValue;
}

FudStatus removeRecursive(const String& path)
{
    if (!path.utf8Valid()) {
        return FudStatus::Utf8Invalid;
    }
    if (path.length() < 5) {
        return FudStatus::ArgumentInvalid;
    }
    auto prefix{String::makeFromCString("/tmp/").takeOkay()};
    auto diffResult = compareMem(path.data(), path.length(), prefix.data(), prefix.length());
    if (diffResult.isError()) {
        return FudStatus::ArgumentInvalid;
    }
    auto diff = diffResult.getOkay();
    if (diff != 0) {
        return FudStatus::ArgumentInvalid;
    }
    constexpr int maxOpenFd = 64;
    auto status = nftw(path.c_str(), unlink_cb, maxOpenFd, FTW_DEPTH | FTW_PHYS);
    if (status == 0) {
        return FudStatus::Success;
    }

    if (errno == ENOENT) {
        return FudStatus::Success;
    }

    return FudStatus::Failure;
}

} // namespace fud