#include "fesa/analysis/linear_static_analysis.h"

#include <gtest/gtest.h>

#include <array>
#include <atomic>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include <hdf5.h>

#include "fesa/analysis/analysis.h"
#include "fesa/app/fesa_application.h"
#include "fesa/assembly/parallel_for.h"
#include "fesa/results/results_writer.h"
#include "fesa/solvers/linear/mkl_pardiso_solver.h"

namespace {

class TempDirectory {
 public:
  explicit TempDirectory(const std::string& label) {
    static std::atomic<unsigned long long> sequence{0U};
    const auto tick =
        std::chrono::steady_clock::now().time_since_epoch().count();
    path_ = std::filesystem::temp_directory_path() /
            ("fesa-surface-pressure-linear-" + label + "-" +
             std::to_string(tick) + "-" +
             std::to_string(sequence.fetch_add(1U)));
    std::error_code error;
    if (!std::filesystem::create_directory(path_, error) || error) {
      throw std::runtime_error{"Unable to create surface pressure fixture."};
    }
  }

  TempDirectory(const TempDirectory&) = delete;
  TempDirectory& operator=(const TempDirectory&) = delete;

  ~TempDirectory() {
    std::error_code ignored;
    std::filesystem::remove_all(path_, ignored);
  }

  const std::filesystem::path& Path() const noexcept { return path_; }

 private:
  std::filesystem::path path_;
};

void WriteText(const std::filesystem::path& path, const std::string& text) {
  std::ofstream stream{path, std::ios::binary | std::ios::trunc};
  stream.write(text.data(), static_cast<std::streamsize>(text.size()));
  if (!stream) {
    throw std::runtime_error{"Unable to write surface pressure input."};
  }
}

std::string ShellDeck(const std::string& source_type,
                      const std::string& connectivity,
                      const bool prescribed_displacement,
                      const bool with_pressure) {
  std::string boundary;
  if (prescribed_displacement) {
    boundary = R"inp(*Boundary
N1, 1, 6
N2, 1, 2
N2, 3, 3, 5.0
N2, 4, 6
N3, 1, 6
N4, 1, 6
)inp";
  } else {
    boundary = "*Boundary\nAll, 1, 6\n";
  }
  const std::string surface = with_pressure
                                  ? "*Surface, TYPE=ELEMENT, NAME=Pressure\n"
                                    "Shell-1.1, SPOS\n"
                                  : "";
  const std::string dsload = with_pressure
                                 ? "*Dsload\nPressure, P, 4.0\n"
                                 : "";
  return std::string{R"inp(*Part, name=ShellPart
*Node
1, 0., 0., 0.
2, 1., 0., 0.
3, 1., 1., 0.
4, 0., 1., 0.
*Element, type=)inp"} +
         source_type + "\n1, " + connectivity + R"inp(
*Elset, elset=ShellSet
1
*Shell Section, elset=ShellSet, material=Steel
0.1
*End Part
*Assembly, name=Assembly
*Instance, name=Shell-1, part=ShellPart
*End Instance
)inp" +
         surface + R"inp(*Nset, nset=N1, instance=Shell-1
1
*Nset, nset=N2, instance=Shell-1
2
*Nset, nset=N3, instance=Shell-1
3
*Nset, nset=N4, instance=Shell-1
4
*Nset, nset=All, instance=Shell-1
1, 2, 3, 4
*End Assembly
*Material, name=Steel
*Elastic
1000., 0.25
)inp" +
         boundary + R"inp(*Step, name=Load, nlgeom=NO
*Static
0.1, 1., 0.01, 1.
)inp" +
         dsload + "*End Step\n";
}

class CapturingResultsWriter final : public fesa::ResultsWriter {
 public:
  fesa::Status Write(const std::filesystem::path&, const fesa::Domain&,
                     const fesa::AnalysisState& state,
                     const std::vector<fesa::Diagnostic>&) override {
    state_ = std::make_unique<fesa::AnalysisState>(state);
    return fesa::Status::Ok();
  }

  const fesa::AnalysisState& State() const {
    if (!state_) {
      throw std::logic_error{"No linear state was captured."};
    }
    return *state_;
  }

 private:
  std::unique_ptr<fesa::AnalysisState> state_;
};

fesa::AnalysisState RunLinear(const std::filesystem::path& input,
                              const std::filesystem::path& output) {
  fesa::SerialParallelFor serial;
  fesa::MklPardisoSolver solver;
  CapturingResultsWriter writer;
  std::unique_ptr<fesa::Analysis> analysis =
      std::make_unique<fesa::LinearStaticAnalysis>(serial, solver, writer);
  const fesa::Status status = analysis->Run({input, output});
  if (!status.IsOk()) {
    throw std::runtime_error{status.Diagnostics().empty()
                                 ? "Linear pressure analysis failed."
                                 : status.Diagnostics().front().code};
  }
  return writer.State();
}

std::array<double, 3> SumTranslation(const fesa::Vector& values) {
  std::array<double, 3> sum{};
  for (std::size_t node = 0U; node < values.Size() / 6U; ++node) {
    for (std::size_t component = 0U; component < 3U; ++component) {
      sum[component] += values[node * 6U + component];
    }
  }
  return sum;
}

}  // namespace

TEST(LinearShellSurfacePressure,
     UsesReferenceNormalAndAreaAfterPrescribedDisplacement) {
  TempDirectory directory{"reference-configuration"};
  const auto input = directory.Path() / "prescribed.inp";
  WriteText(input, ShellDeck("S4", "1, 2, 3, 4", true, true));

  const fesa::AnalysisState state =
      RunLinear(input, directory.Path() / "captured.h5");

  EXPECT_DOUBLE_EQ(state.Displacement()[8U], 5.0);
  EXPECT_EQ(SumTranslation(state.ExternalForce()),
            (std::array<double, 3>{0.0, 0.0, -4.0}));
}

TEST(LinearShellSurfacePressure,
     AssemblesBeforeProjectionAndIncludesConstrainedReaction) {
  TempDirectory directory{"reaction"};
  const auto input = directory.Path() / "reaction.inp";
  WriteText(input, ShellDeck("S4", "1, 2, 3, 4", false, true));

  const fesa::AnalysisState state =
      RunLinear(input, directory.Path() / "captured.h5");

  EXPECT_EQ(SumTranslation(state.ExternalForce()),
            (std::array<double, 3>{0.0, 0.0, -4.0}));
  EXPECT_EQ(SumTranslation(state.Reaction()),
            (std::array<double, 3>{0.0, 0.0, 4.0}));
}

TEST(LinearShellSurfacePressure,
     SatisfiesFreeResidualGlobalResultantAndMoment) {
  TempDirectory directory{"equilibrium"};
  const auto input = directory.Path() / "equilibrium.inp";
  WriteText(input, ShellDeck("S4", "1, 2, 3, 4", false, true));

  const fesa::AnalysisState state =
      RunLinear(input, directory.Path() / "captured.h5");

  for (const double value : state.Equilibrium()) {
    EXPECT_NEAR(value, 0.0, 1.0e-8);
  }
  EXPECT_NEAR(state.VerificationMetrics()[0U], 0.0, 1.0e-10);
}

TEST(LinearShellSurfacePressure, PreservesS4S4rMeshAndCyclicOrderInvariance) {
  TempDirectory directory{"source-invariance"};
  const auto s4_input = directory.Path() / "s4.inp";
  const auto s4r_input = directory.Path() / "s4r.inp";
  const auto cyclic_input = directory.Path() / "cyclic.inp";
  WriteText(s4_input, ShellDeck("S4", "1, 2, 3, 4", false, true));
  WriteText(s4r_input, ShellDeck("S4R", "1, 2, 3, 4", false, true));
  WriteText(cyclic_input, ShellDeck("S4", "2, 3, 4, 1", false, true));

  const fesa::AnalysisState s4 =
      RunLinear(s4_input, directory.Path() / "s4.h5");
  const fesa::AnalysisState s4r =
      RunLinear(s4r_input, directory.Path() / "s4r.h5");
  const fesa::AnalysisState cyclic =
      RunLinear(cyclic_input, directory.Path() / "cyclic.h5");

  ASSERT_EQ(s4.ExternalForce().Size(), s4r.ExternalForce().Size());
  ASSERT_EQ(s4.ExternalForce().Size(), cyclic.ExternalForce().Size());
  for (std::size_t index = 0U; index < s4.ExternalForce().Size(); ++index) {
    EXPECT_DOUBLE_EQ(s4.ExternalForce()[index], s4r.ExternalForce()[index]);
    EXPECT_DOUBLE_EQ(s4.ExternalForce()[index], cyclic.ExternalForce()[index]);
    EXPECT_DOUBLE_EQ(s4.Reaction()[index], s4r.Reaction()[index]);
    EXPECT_DOUBLE_EQ(s4.Reaction()[index], cyclic.Reaction()[index]);
  }
}

TEST(LinearShellSurfacePressure, WritesSchemaZeroWithoutPressureDataset) {
  TempDirectory directory{"schema-zero"};
  const auto input = directory.Path() / "pressure.inp";
  const auto output = directory.Path() / "pressure_results.h5";
  WriteText(input, ShellDeck("S4", "1, 2, 3, 4", false, true));

  EXPECT_EQ(fesa::FesaApplication{}.Run({input.string()}), 0);
  ASSERT_GT(H5Fis_hdf5(output.string().c_str()), 0);
  const hid_t file =
      H5Fopen(output.string().c_str(), H5F_ACC_RDONLY, H5P_DEFAULT);
  ASSERT_GE(file, 0);
  const hid_t metadata = H5Gopen2(file, "/metadata", H5P_DEFAULT);
  ASSERT_GE(metadata, 0);
  const hid_t schema = H5Aopen(metadata, "schema_version", H5P_DEFAULT);
  ASSERT_GE(schema, 0);
  std::uint64_t schema_version = 0U;
  ASSERT_GE(H5Aread(schema, H5T_NATIVE_UINT64, &schema_version), 0);
  EXPECT_EQ(schema_version, 0U);
  EXPECT_EQ(H5Lexists(file, "/steps/Step-1/frames/0/surface_pressure",
                       H5P_DEFAULT),
            0);
  EXPECT_EQ(H5Lexists(file, "/pressure", H5P_DEFAULT), 0);
  EXPECT_GE(H5Aclose(schema), 0);
  EXPECT_GE(H5Gclose(metadata), 0);
  EXPECT_GE(H5Fclose(file), 0);
}