// main.rs
#![allow(warnings)]

mod model;
mod view;
mod observer;
mod event;
mod controller;

use std::cell::RefCell;
use std::rc::Rc;

use model::Model;
use view::View;
use controller::Controller;

fn main() {
    let mut model = Model::new(42);

    let mut view = View::new();

    let mut controller = Controller::new(&mut model, &mut view);

    controller.run();
}

// model.rs
pub struct Model
{
    pub x: i32
}

impl Model
{
    pub fn new(x: i32) -> Self
    {
        return Self { x };
    }
}

// view.rs
use std::cell::RefCell;
use std::rc::Rc;
use read_input::InputBuild;
use read_input::prelude::input;

use crate::model::Model;
use crate::event::Event;

pub struct View
{
    pub input_submitted: Event<i32>
}

impl View
{
    pub fn new() -> Self
    {
        return Self
        {
            input_submitted: Event::<i32>::new()
        };
    }

    pub fn render(&self, model: &Model)
    {
        println!();
        println!("Render... (x = {})", &model.x);
        let input: i32 = input().repeat_msg("Input = ").get();
        self.input_submitted.invoke(input);
    }
}

// controller.rs
use std::cell::RefCell;
use std::rc::Rc;
use crate::model::Model;
use crate::observer::Observer;
use crate::view::View;

pub struct Controller<'a>
{
    model: &'a mut Model,
    view: &'a View,
}

impl<'a> Controller<'a>
{
    pub fn new(model: &'a mut Model, view: &'a mut View, x: impl Default) -> Self
    {
        let observer = ViewObserver { model };
        view.input_submitted.subscribe(Box::new(observer));
        let controller = Controller { model, view };
        return controller;
    }

    pub fn run(&mut self)
    {
        loop
        {
            self.view.render(self.model);
        }
    }
}

struct ViewObserver<'a>
{
    model: &'a mut Model
}

impl Observer<i32> for ViewObserver<'_>
{
    fn invoke(&self, arg1: i32)
    {
        println!("Input received (x = {})", arg1);
    }
}

// event.rs
use crate::observer::Observer;

pub struct Event<T1>
{
    subscribers: Vec<Box<dyn Observer<T1>>>
}

impl<T1> Event<T1> where T1 : Clone
{
    pub fn new() -> Self
    {
        return Self
        {
            subscribers: Vec::new()
        };
    }

    pub fn subscribe(&mut self, arg: Box<dyn Observer<T1>>)
    {
        self.subscribers.push(arg);
    }

    pub fn invoke(&self, arg1: T1)
    {
        for subscriber in &self.subscribers
        {
            subscriber.invoke(arg1.clone());
        }
    }
}

// observer.rs
pub trait Observer<T1>
{
    fn invoke(&self, arg1: T1);
}