#pragma once

#include <stdexcept>
#include <utility>

// Исключение этого типа должно генерироватся при обращении к пустому optional
class BadOptionalAccess : public std::exception {
public:
    using exception::exception;

    virtual const char* what() const noexcept override {
        return "Bad optional access";
    }
};

template <typename T>
class Optional {
public:
    Optional() = default;

    Optional(const T& value) {
        ptr_ = new (&data_[0]) T(value);
        is_initialized_ = true;
    }

    Optional(T&& value) {
        ptr_ = new (&data_[0]) T(std::move(value));
        is_initialized_ = true;
    }

    Optional(const Optional& other) {
        ptr_ = new (&data_[0]) T(*other.ptr_);
        is_initialized_ = true;
    }

    Optional(Optional&& other) {
        ptr_ = other.ptr_;
        is_initialized_ = true;
    }

    Optional& operator=(const T& value) {
        ptr_ = new (&data_[0]) T(value);
        is_initialized_ = true;
        return *this;
    }

    Optional& operator=(T&& value) {
        ptr_ = new (&data_[0]) T(std::move(value));
        is_initialized_ = true;
        return *this;
    }

    Optional& operator=(const Optional& rhs) {
        ptr_ = new (&data_[0]) T(*rhs.ptr_);
        is_initialized_ = true;
        return *this;
    }

    Optional& operator=(Optional&& rhs) {
        delete[] data_;
        ptr_ = rhs.ptr_;
        is_initialized_ = true;
        return *this;
    }


    ~Optional() {
        delete[] ptr_;
    }

    bool HasValue() const {
        return is_initialized_;
    }

    // Операторы * и -> не должны делать никаких проверок на пустоту Optional.
    // Эти проверки остаются на совести программиста
    T& operator*() {
        return *ptr_;
    }

    const T& operator*() const {
        return *ptr_;
    }

    T* operator->() {
        return ptr_;
    }

    const T* operator->() const {
        return ptr_;
    }

    // Метод Value() генерирует исключение BadOptionalAccess, если Optional пуст
    T& Value() {
        if (!is_initialized_) {
            throw BadOptionalAccess();
        }
        return *ptr_;
    }
    const T& Value() const {
        if (!is_initialized_) {
            throw BadOptionalAccess();
        }
        return *ptr_;
    }

    void Reset() {
        is_initialized_ = false;
        ptr_ = nullptr;
    }

private:
    // alignas нужен для правильного выравнивания блока памяти
    alignas(T) char data_[sizeof(T)];
    bool is_initialized_ = false;
    T* ptr_ = nullptr;
};