#include "fesa/core/status.h"

#include <gtest/gtest.h>

#include <filesystem>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

namespace {

fesa::Diagnostic ModelDiagnostic() {
  return fesa::Diagnostic{fesa::Severity::kError,
                          "invalid-beam-length",
                          {std::filesystem::path{"beam.inp"}, 12U},
                          "*ELEMENT",
                          "Beam-1.10",
                          "Beam length must be positive."};
}

}  // namespace

TEST(CoreDiagnostics, ResultEnforcesValueErrorExclusivity) {
  const fesa::Status ok = fesa::Status::Ok();
  EXPECT_TRUE(ok.IsOk());
  EXPECT_FALSE(ok.Category().has_value());
  EXPECT_TRUE(ok.Diagnostics().empty());

  const fesa::Status uncategorized =
      fesa::Status::Failure(std::vector<fesa::Diagnostic>{ModelDiagnostic()});
  EXPECT_FALSE(uncategorized.IsOk());
  EXPECT_FALSE(uncategorized.Category().has_value());
  ASSERT_EQ(uncategorized.Diagnostics().size(), 1U);
  EXPECT_EQ(uncategorized.Diagnostics()[0].code, "invalid-beam-length");

  const fesa::Status categorized =
      fesa::Status::Failure(fesa::FailureCategory::kModel,
                            std::vector<fesa::Diagnostic>{ModelDiagnostic()});
  EXPECT_FALSE(categorized.IsOk());
  ASSERT_TRUE(categorized.Category().has_value());
  EXPECT_EQ(*categorized.Category(), fesa::FailureCategory::kModel);

  const auto success = fesa::Result<std::string>::Success("solved");
  EXPECT_TRUE(success.HasValue());
  EXPECT_TRUE(success.GetStatus().IsOk());
  EXPECT_EQ(success.Value(), "solved");

  auto copied = success;
  EXPECT_EQ(copied.Value(), "solved");
  auto moved = std::move(copied);
  EXPECT_EQ(moved.Value(), "solved");

  auto failure = fesa::Result<std::string>::Failure(categorized);
  EXPECT_FALSE(failure.HasValue());
  EXPECT_FALSE(failure.GetStatus().IsOk());
  EXPECT_EQ(failure.GetStatus().Category(), fesa::FailureCategory::kModel);
  EXPECT_THROW(failure.Value(), std::logic_error);

  const auto& const_failure = failure;
  EXPECT_THROW(const_failure.Value(), std::logic_error);
  EXPECT_THROW((void)fesa::Result<std::string>::Failure(fesa::Status::Ok()),
               std::invalid_argument);
}