#include <iostream>
#include <memory>

class Base1 {
public:
    virtual ~Base1() = default;

    virtual  void fun1() const {
        std::cout << "fun1=" << a << std::endl;
    }

    virtual void fun2() const {
        std::cout << "fun2=" << a << std::endl;
    }

    virtual void fun3() const {
        std::cout << "fun3=" << a << std::endl;
    }

    virtual void fun4() const {
        std::cout << "fun4=" << a << std::endl;
    }
private:
    int a = 0;
};

class V1 : public Base1 {
public:
    void fun1() const override {
        std::cout << "_fun1=" << a << std::endl;
    }
private:
    int a = 1;
};

class V2 : public V1 {
public:
    void fun2() const override {
        std::cout << "__fun2=" << a << std::endl;
    }
private:
    int a = 2;
};

class V3 final : public V2 {
public:
    void fun3() const override {
        std::cout << "___fun2=" << a << std::endl;
    }
private:
    int a = 3;
};

int main() {
    const auto v3 = std::make_unique<V3>();

    v3->fun1();
    v3->fun2();
    v3->fun3();
    v3->fun4();

    return 0;
}

trait Base1Ops {
    // доступ к "Base1::a"
    fn base1_a(&self) -> i32;

    // виртуальные методы (есть дефолт, как в Base1)
    fn fun1(&self) {
        println!("fun1={}", self.base1_a());
    }
    fn fun2(&self) {
        println!("fun2={}", self.base1_a());
    }
    fn fun3(&self) {
        println!("fun3={}", self.base1_a());
    }
    fn fun4(&self) {
        println!("fun4={}", self.base1_a());
    }
}

struct Base1 {
    a: i32,
}

impl Base1 {
    fn new() -> Self {
        Self { a: 0 }
    }
}

impl Base1Ops for Base1 {
    fn base1_a(&self) -> i32 {
        self.a
    }
}

struct V1 {
    base: Base1,
    a: i32, // V1::a
}

impl V1 {
    fn new() -> Self {
        Self {
            base: Base1::new(),
            a: 1,
        }
    }
}

impl Base1Ops for V1 {
    fn base1_a(&self) -> i32 {
        self.base.a
    }

    fn fun1(&self) {
        println!("_fun1={}", self.a);
    }
}

struct V2 {
    v1: V1,
    a: i32, // V2::a
}

impl V2 {
    fn new() -> Self {
        Self { v1: V1::new(), a: 2 }
    }
}

impl Base1Ops for V2 {
    fn base1_a(&self) -> i32 {
        self.v1.base.a
    }

    // наследуем поведение V1::fun1
    fn fun1(&self) {
        self.v1.fun1();
    }

    fn fun2(&self) {
        println!("__fun2={}", self.a);
    }
}

struct V3 {
    v2: V2,
    a: i32, // V3::a
}

impl V3 {
    fn new() -> Self {
        Self { v2: V2::new(), a: 3 }
    }
}

impl Base1Ops for V3 {
    fn base1_a(&self) -> i32 {
        self.v2.v1.base.a
    }

    // наследуем поведение V1::fun1 и V2::fun2
    fn fun1(&self) {
        self.v2.fun1();
    }
    fn fun2(&self) {
        self.v2.fun2();
    }

    fn fun3(&self) {
        // в исходнике строка "___fun2=" (хотя это fun3) — сохраняю как есть
        println!("___fun2={}", self.a);
    }
    // fun4 не переопределяем => будет Base1-версия через дефолт
}

fn main() {
    let v3 = Box::new(V3::new());

    v3.fun1();
    v3.fun2();
    v3.fun3();
    v3.fun4();
}

// g++ -std=c++20 -O2 -Wall -Wextra -pedantic main.cpp && ./a.out
#include <iostream>
#include <string>
#include <stdexcept>

// --------- Interfaces (abstract_reader / abstract_mutator) ---------

struct abstract_reader {
  virtual ~abstract_reader() = default;

  virtual int get_a() const = 0;
  virtual int get_b() const = 0;
  virtual std::string describe() const = 0;
};

struct abstract_mutator : abstract_reader {
  virtual void set_a(int v) = 0;
  virtual void set_b(int v) = 0;
};

// --------- "basic_impl": common logic + customization points ---------

class basic_impl {
protected:
  // customization points (hooks)
  virtual int calculate_a() const = 0;
  virtual int calculate_b() const = 0;

  int impl_get_a() const {
    helper_validate_ready();
    if (!cache_a_valid_) {
      cache_a_ = helper_mix("A", calculate_a());
      cache_a_valid_ = true;
    }
    return cache_a_;
  }

  int impl_get_b() const {
    helper_validate_ready();
    if (!cache_b_valid_) {
      cache_b_ = helper_mix("B", calculate_b());
      cache_b_valid_ = true;
    }
    return cache_b_;
  }

  std::string impl_describe() const {
    return "a=" + std::to_string(impl_get_a()) + ", b=" + std::to_string(impl_get_b());
  }

  void helper_invalidate_cache() {
    cache_a_valid_ = false;
    cache_b_valid_ = false;
  }

  void helper_set_ready(bool v) { ready_ = v; }

private:
  void helper_validate_ready() const {
    if (!ready_) throw std::logic_error("object is not ready");
  }

  static int helper_mix(const char* tag, int v) {
    int salt = (tag[0] == 'A') ? 10 : 20;
    return v + salt;
  }

private:
  bool ready_ = true;
  mutable bool cache_a_valid_ = false;
  mutable bool cache_b_valid_ = false;
  mutable int cache_a_ = 0;
  mutable int cache_b_ = 0;
};

// --------- reader ---------

class reader final
  : public abstract_reader
  , protected basic_impl
{
public:
  explicit reader(int base) : base_(base) {}

  int get_a() const override { return impl_get_a(); }
  int get_b() const override { return impl_get_b(); }
  std::string describe() const override { return "reader{" + impl_describe() + "}"; }

protected:
  int calculate_a() const override { return base_ * 3 + 1; }
  int calculate_b() const override { return base_ * base_; }

private:
  int base_;
};

// --------- mutator ---------

class mutator final
  : public abstract_mutator
  , protected basic_impl
{
public:
  mutator(int a, int b) : a_(a), b_(b) {}

  int get_a() const override { return impl_get_a(); }
  int get_b() const override { return impl_get_b(); }
  std::string describe() const override { return "mutator{" + impl_describe() + "}"; }

  void set_a(int v) override {
    a_ = v;
    helper_invalidate_cache();
  }

  void set_b(int v) override {
    b_ = v;
    helper_invalidate_cache();
  }

  void set_ready(bool v) { helper_set_ready(v); }

protected:
  int calculate_a() const override { return a_ * 2; }
  int calculate_b() const override { return b_ + 7; }

private:
  int a_;
  int b_;
};

// --------- Demo ---------

static void print_reader(const abstract_reader& r, const char* title) {
  std::cout << title << ": " << r.describe()
            << " (get_a=" << r.get_a()
            << ", get_b=" << r.get_b()
            << ")\n";
}

int main() {
  try {
    reader r{5};
    print_reader(r, "r first");
    print_reader(r, "r second (cached)");

    mutator m{10, 3};
    print_reader(m, "m initial");
    m.set_a(11);
    print_reader(m, "m after set_a(11)");
    m.set_b(100);
    print_reader(m, "m after set_b(100)");

    m.set_ready(false);
    std::cout << "m set_ready(false)\n";

    // Хотим именно "m.get_a(): Exception: ..."
    std::cout << "m.get_a(): ";
    try {
      std::cout << m.get_a() << "\n";
    } catch (const std::exception& e) {
      std::cout << "Exception: " << e.what() << "\n";
    }
  }
  catch (const std::exception& e) {
    std::cout << "Exception: " << e.what() << "\n";
  }
}

// rustc main.rs && ./main
//
// Вывод (по смыслу как в C++ версии):
// r first: reader{a=26, b=45} (get_a=26, get_b=45)
// r second (cached): reader{a=26, b=45} (get_a=26, get_b=45)
// m initial: mutator{a=30, b=30} (get_a=30, get_b=30)
// m after set_a(11): mutator{a=32, b=30} (get_a=32, get_b=30)
// m after set_b(100): mutator{a=32, b=127} (get_a=32, get_b=127)
// m set_ready(false)
// m.get_a(): Exception: object is not ready

use std::cell::Cell;
use std::fmt;

// --------- Error type (instead of C++ exception) ---------

#[derive(Debug, Clone, Copy)]
enum ReadError {
    NotReady,
}

impl fmt::Display for ReadError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ReadError::NotReady => write!(f, "object is not ready"),
        }
    }
}

// --------- Interfaces (abstract_reader / abstract_mutator) ---------

trait Reader {
    fn get_a(&self) -> Result<i32, ReadError>;
    fn get_b(&self) -> Result<i32, ReadError>;
    fn describe(&self) -> Result<String, ReadError>;
}

trait Mutator: Reader {
    fn set_a(&mut self, v: i32);
    fn set_b(&mut self, v: i32);
}

// --------- "basic_impl" state (private base data) ---------

struct BasicState {
    ready: Cell<bool>,

    cache_a_valid: Cell<bool>,
    cache_b_valid: Cell<bool>,
    cache_a: Cell<i32>,
    cache_b: Cell<i32>,
}

impl BasicState {
    fn new() -> Self {
        Self {
            ready: Cell::new(true),
            cache_a_valid: Cell::new(false),
            cache_b_valid: Cell::new(false),
            cache_a: Cell::new(0),
            cache_b: Cell::new(0),
        }
    }

    fn validate_ready(&self) -> Result<(), ReadError> {
        if self.ready.get() {
            Ok(())
        } else {
            Err(ReadError::NotReady)
        }
    }

    fn set_ready(&self, v: bool) {
        self.ready.set(v);
    }

    fn invalidate_cache(&self) {
        self.cache_a_valid.set(false);
        self.cache_b_valid.set(false);
    }
}

// --------- "basic_impl" logic + customization points (hooks) ---------

trait BasicImpl {
    // доступ к "private данным базового класса"
    fn basic(&self) -> &BasicState;

    // hooks
    fn calculate_a(&self) -> i32;
    fn calculate_b(&self) -> i32;

    fn helper_mix(tag: &str, v: i32) -> i32 {
        let salt = match tag {
            "A" => 10,
            "B" => 20,
            _ => 0,
        };
        v + salt
    }

    fn impl_get_a(&self) -> Result<i32, ReadError> {
        self.basic().validate_ready()?;

        if !self.basic().cache_a_valid.get() {
            let v = Self::helper_mix("A", self.calculate_a());
            self.basic().cache_a.set(v);
            self.basic().cache_a_valid.set(true);
        }
        Ok(self.basic().cache_a.get())
    }

    fn impl_get_b(&self) -> Result<i32, ReadError> {
        self.basic().validate_ready()?;

        if !self.basic().cache_b_valid.get() {
            let v = Self::helper_mix("B", self.calculate_b());
            self.basic().cache_b.set(v);
            self.basic().cache_b_valid.set(true);
        }
        Ok(self.basic().cache_b.get())
    }

    fn impl_describe(&self) -> Result<String, ReadError> {
        Ok(format!("a={}, b={}", self.impl_get_a()?, self.impl_get_b()?))
    }

    // "protected helpers"
    fn helper_invalidate_cache(&self) {
        self.basic().invalidate_cache();
    }

    fn helper_set_ready(&self, v: bool) {
        self.basic().set_ready(v);
    }
}

// --------- reader ---------

struct ReaderImpl {
    basic: BasicState,
    base: i32,
}

impl ReaderImpl {
    fn new(base: i32) -> Self {
        Self {
            basic: BasicState::new(),
            base,
        }
    }
}

impl BasicImpl for ReaderImpl {
    fn basic(&self) -> &BasicState {
        &self.basic
    }

    fn calculate_a(&self) -> i32 {
        self.base * 3 + 1
    }

    fn calculate_b(&self) -> i32 {
        self.base * self.base
    }
}

impl Reader for ReaderImpl {
    fn get_a(&self) -> Result<i32, ReadError> {
        self.impl_get_a()
    }

    fn get_b(&self) -> Result<i32, ReadError> {
        self.impl_get_b()
    }

    fn describe(&self) -> Result<String, ReadError> {
        Ok(format!("reader{{{}}}", self.impl_describe()?))
    }
}

// --------- mutator ---------

struct MutatorImpl {
    basic: BasicState,
    a: i32,
    b: i32,
}

impl MutatorImpl {
    fn new(a: i32, b: i32) -> Self {
        Self {
            basic: BasicState::new(),
            a,
            b,
        }
    }

    fn set_ready(&self, v: bool) {
        self.helper_set_ready(v);
    }
}

impl BasicImpl for MutatorImpl {
    fn basic(&self) -> &BasicState {
        &self.basic
    }

    fn calculate_a(&self) -> i32 {
        self.a * 2
    }

    fn calculate_b(&self) -> i32 {
        self.b + 7
    }
}

impl Reader for MutatorImpl {
    fn get_a(&self) -> Result<i32, ReadError> {
        self.impl_get_a()
    }

    fn get_b(&self) -> Result<i32, ReadError> {
        self.impl_get_b()
    }

    fn describe(&self) -> Result<String, ReadError> {
        Ok(format!("mutator{{{}}}", self.impl_describe()?))
    }
}

impl Mutator for MutatorImpl {
    fn set_a(&mut self, v: i32) {
        self.a = v;
        self.helper_invalidate_cache();
    }

    fn set_b(&mut self, v: i32) {
        self.b = v;
        self.helper_invalidate_cache();
    }
}

// --------- Demo ---------

fn print_reader(title: &str, r: &dyn Reader) {
    // как и в C++: здесь ожидаем, что объект "готов"
    let desc = r.describe().unwrap();
    let a = r.get_a().unwrap();
    let b = r.get_b().unwrap();

    println!("{title}: {desc} (get_a={a}, get_b={b})");
}

fn main() {
    let r = ReaderImpl::new(5);
    print_reader("r first", &r);
    print_reader("r second (cached)", &r);

    let mut m = MutatorImpl::new(10, 3);
    print_reader("m initial", &m);
    m.set_a(11);
    print_reader("m after set_a(11)", &m);
    m.set_b(100);
    print_reader("m after set_b(100)", &m);

    m.set_ready(false);
    println!("m set_ready(false)");

    // хотим ровно как в C++:
    // std::cout << "m.get_a(): ";
    // try { std::cout << m.get_a(); } catch(...) { std::cout << "Exception: ..."; }
    print!("m.get_a(): ");
    match m.get_a() {
        Ok(v) => println!("{v}"),
        Err(e) => println!("Exception: {e}"),
    }
}