#pragma once
///////////////////////////////////////////////////////////////////////
// NamedType.h - Defines Strong Types                                //
//                                                                   //
// Jim Fawcett, CSE687 - Object Oriented Design, Spring 2018         //
///////////////////////////////////////////////////////////////////////
//
// Acknowledgement:
// -Almost all of the ideas used in this solution were discussed clearly by
//  Jonathan Boccara here :
//  https://www.fluentcpp.com/2016/12/08/strong-types-for-strong-interfaces/
//
// - The code given here has adaptions of his code samples.

#include <type_traits>
#include <iostream>

template <typename T, typename TypeName>
class NamedType
{
public:
  explicit NamedType(T const& value) : value_(value) {}
  T& get() { return value_; }
  T const& get() const { return value_; }
  explicit operator T&() { return value_; }
private:
  T value_;
};

template<typename T, typename TypeName>
std::ostream& operator<<(std::ostream& out, NamedType<T, TypeName>& arg)
{
  out << arg.get();
  return out;
}

template <typename T, template<typename> class crtpType>
struct crtp
{
  T& underlying() { return static_cast<T&>(*this); }
  T const& underlying() const { return static_cast<T const&>(*this); }
};

template <typename T>
struct Addable : crtp<T, Addable>
{
  T operator+(T const& other) { return T(this->underlying().get() + other.get()); }
  T operator-(T const& other) { return T(this->underlying().get() - other.get()); }
};

template <typename T, typename TypeName>
class AddableNamedType : public Addable<AddableNamedType<T, TypeName>> 
{
public:
  explicit AddableNamedType(T const& value) : value_(value) {}
  T& get() { return value_; }
  T const& get() const { return value_; }
  explicit operator T&() { return value_; }
private:
  T value_;
};

template<typename T, typename TypeName>
std::ostream& operator<<(std::ostream& out, AddableNamedType<T, TypeName>& arg)
{
  out << arg.get();
  return out;
}

using Meter = AddableNamedType<double, struct MeterType>;
using Yard = AddableNamedType<double, struct YardType>;

//template <typename T, typename TypeName = struct NullType {}>
//class AddableNamedType : public NamedType<T, TypeName>, Addable<AddableNamedType<T, TypeName>> {};