#include <gtest/gtest.h>

#include <memory>
#include <string>

#include "utils/result.h"

namespace rk3588 {
namespace {

TEST(ResultTest, VoidResultOk) {
    Status s = Status::Ok();
    EXPECT_TRUE(s.IsOk());
    EXPECT_FALSE(s.Failed());
    EXPECT_TRUE(static_cast<bool>(s));
    EXPECT_TRUE(s.ErrMessage().empty());
}

TEST(ResultTest, VoidResultFail) {
    Status s = Status::Fail("something went wrong");
    EXPECT_FALSE(s.IsOk());
    EXPECT_TRUE(s.Failed());
    EXPECT_FALSE(static_cast<bool>(s));
    EXPECT_EQ(s.ErrMessage(), "something went wrong");
}

TEST(ResultTest, VoidResultFailWithCode) {
    Status s = Status::Fail("error", 42);
    EXPECT_FALSE(s.IsOk());
    EXPECT_EQ(s.Err().Code(), 42);
    EXPECT_EQ(s.ErrMessage(), "error");
}

TEST(ResultTest, ValueResultOk) {
    Result<int> r = 42;
    EXPECT_TRUE(r.Ok());
    EXPECT_FALSE(r.Failed());
    EXPECT_TRUE(static_cast<bool>(r));
    EXPECT_EQ(r.Value(), 42);
}

TEST(ResultTest, ValueResultFail) {
    Result<int> r = Error("failed to compute");
    EXPECT_FALSE(r.Ok());
    EXPECT_TRUE(r.Failed());
    EXPECT_FALSE(static_cast<bool>(r));
    EXPECT_EQ(r.ErrMessage(), "failed to compute");
}

TEST(ResultTest, ValueResultValueOr) {
    Result<int> ok = 100;
    Result<int> fail = Error("oops");

    EXPECT_EQ(ok.ValueOr(0), 100);
    EXPECT_EQ(fail.ValueOr(0), 0);
}

TEST(ResultTest, ValueResultTake) {
    Result<std::string> r = std::string("hello");
    EXPECT_TRUE(r.Ok());
    std::string s = std::move(r).Take();
    EXPECT_EQ(s, "hello");
}

TEST(ResultTest, StringResult) {
    Result<std::string> ok = std::string("success");
    Result<std::string> fail = Error("failure");

    EXPECT_TRUE(ok.Ok());
    EXPECT_EQ(ok.Value(), "success");

    EXPECT_TRUE(fail.Failed());
    EXPECT_EQ(fail.ErrMessage(), "failure");
}

TEST(ResultTest, MakeResultHelper) {
    auto r = MakeResult<int>(123);
    EXPECT_TRUE(r.Ok());
    EXPECT_EQ(r.Value(), 123);
}

TEST(ResultTest, MakeErrorHelper) {
    auto r = MakeError<int>("test error");
    EXPECT_TRUE(r.Failed());
    EXPECT_EQ(r.ErrMessage(), "test error");
}

TEST(ErrorTest, Basic) {
    Error e1;
    EXPECT_TRUE(e1.Empty());
    EXPECT_FALSE(static_cast<bool>(e1));

    Error e2("message", 100);
    EXPECT_FALSE(e2.Empty());
    EXPECT_TRUE(static_cast<bool>(e2));
    EXPECT_EQ(e2.Message(), "message");
    EXPECT_EQ(e2.Code(), 100);
}

TEST(ResultTest, OkStatusHelper) {
    Status s = OkStatus();
    EXPECT_TRUE(s.IsOk());
}

TEST(ResultTest, FailStatusHelper) {
    Status s = FailStatus("test");
    EXPECT_TRUE(s.Failed());
    EXPECT_EQ(s.ErrMessage(), "test");
}

// Test with complex types
struct ComplexType {
    int x;
    std::string s;
    bool operator==(const ComplexType& o) const { return x == o.x && s == o.s; }
};

TEST(ResultTest, ComplexType) {
    Result<ComplexType> ok = ComplexType{42, "test"};
    EXPECT_TRUE(ok.Ok());
    EXPECT_EQ(ok.Value().x, 42);
    EXPECT_EQ(ok.Value().s, "test");

    Result<ComplexType> fail = Error("complex error");
    EXPECT_TRUE(fail.Failed());
}

// Test move semantics
TEST(ResultTest, MoveSemantics) {
    Result<std::unique_ptr<int>> r = std::make_unique<int>(42);
    EXPECT_TRUE(r.Ok());
    auto ptr = std::move(r).Take();
    EXPECT_EQ(*ptr, 42);
}

}  // namespace
}  // namespace rk3588