#pragma once

#include <forstio/core/string_literal.h>
#include <forstio/core/error.h>
#include <forstio/codec/data.h>

#include <netcdf.h>
#include <netcdf_mem.h>

namespace saw {
namespace encode {
/**
 * Template type hint
 */
struct Netcdf {};
}

/**
 * Class representing the files system netcdf file
 */
template<typename Schema>
class data<Schema, encode::Netcdf> {
private:
		std::vector<uint8_t> buff_;
public:
		data(std::vector<uint8_t> buff):
				buff_{std::move(buff)}
		{}

		template<size_t N>
		data(const std::array<uint8_t, N>& arr):
			buff_{arr.begin(), arr.end()}
		{}

		std::vector<uint8_t>& get_data() {
				return buff_;
		}

		const std::vector<uint8_t>& get_data() const {
				return buff_;
		}
};

template<typename Schema>
class codec<Schema, encode::Netcdf>{
		static_assert(always_false<Schema,encode::Netcdf>, "NetCDF only supports Structs as a root object");
};

}
#include "netcdf.tmpl.h"
namespace saw {

template<typename... Vals, string_literal... Keys>
class codec<schema::Struct<schema::Member<Vals,Keys>...>, encode::Netcdf> {
private:
		using Schema = schema::Struct<schema::Member<Vals,Keys>...>;
public:
		SAW_FORBID_COPY(codec);
		SAW_DEFAULT_MOVE(codec);

		/**
		 * Default constructor
		 */
		codec() = default;

		/**
		 * Encoder function
		 */
		template<typename FromEncoding>
		error_or<void> encode() {
				return make_error<err::not_implemented>();
		}

		/**
		 * Decoder function
		 */
		template<typename ToEncoding>
		error_or<void> decode(data<Schema, encode::Netcdf>& from_decode, data<Schema,ToEncoding>& to_decode) {
				int ncid{};
				int rc{};

				rc = nc_open_mem("forstio_internal_memory", NC_NOWRITE, from_decode.get_data().size(), &from_decode.get_data()[0], &ncid);
				if(rc != NC_NOERR){
						// Don't know how to get the error, so fail critically.
						return make_error<err::critical>();
				}

				auto eov = impl::netcdf_decode<Schema, ToEncoding>::decode(to_decode, ncid);

				nc_close(ncid);

				return eov;
		}
};
}