use std::borrow::Cow;

pub struct Controller<'a, I: Internals> {
	state: ControllerState<'a>,
	internals: I,
}

impl<'a, I: Internals> Controller<'a, I> {
	pub fn build(internals: I) -> Builder<I> {
		Builder { internals }
	}

	pub fn internals(&self) -> &I {
		&self.internals
	}

	pub fn do_something(&mut self) -> String {
		self.internals.update_things(&mut UpdateThingsEvent {
			state: &mut self.state,
		});

		self.state.things.join(", ")
	}
}

pub struct ControllerState<'a> {
	things: Vec<Cow<'a, str>>,
}

impl<'a> ControllerState<'a> {
	pub fn things_mut(&mut self) -> &mut Vec<Cow<'a, str>> {
		&mut self.things
	}

	// TODO: how do we have a method here that references internals?
}

pub struct Builder<I: Internals> {
	internals: I,
}

impl<I: Internals> Builder<I> {
	pub fn finalize<'a>(self) -> Controller<'a, I> {
		let Self { internals } = self;

		Controller {
			internals,
			state: ControllerState {
				things: Vec::new(),
			},
		}
	}
}

pub trait Internals {
	fn update_things(&mut self, _state: &mut UpdateThingsEvent) {
		_state.state.things_mut().push("lightship-thing".into());
	}
}

pub struct UpdateThingsEvent<'a> {
	state: &'a mut ControllerState<'a>,
}

impl<'a> UpdateThingsEvent<'a> {
	pub fn state(&mut self) -> &'a mut ControllerState {
		self.state
	}
}