@startuml

!include style.ipuml

' !include hide-groups.ipuml
' !include hide-details.ipuml

class main as "main()"
hide main circle
hide main members

exception Exception {
	+ Exception(const char* fmt, ...)
	+ what() : const char*
	--
	# error : char*
	# va_format(va_list args, const char* fmt)
}

rectangle Group_FileReading as "File reading" <<group>> {
	class FileReader <<Factory>> {
		+open(url) : FileStrategy&
	}
	interface FileStrategy {
		+ read() : string
		+ close()
		--
		# open(string url)
		# clone() : FileStrategy* <<const>>
	}
	class LocalFile {
		- instance : LocalFile <<static>>
	}
	class HTTPFile {
		- instance : HTTPFile <<static>>
	}
	package CPR {
		class Response <<irrelevant>>
		class Url <<irrelevant>>
	}

	FileStrategy <|.. LocalFile
	FileStrategy <|.. HTTPFile

	FileStrategy <. FileReader
	FileStrategy .> FileReader

	HTTPFile --> CPR.Response
	CPR.Response - CPR.Url
}
rectangle Group_ParsingDeserialization as "Parsing & deserialization" <<group>> {
	class Parser {
		+ parse(File, Deserializer) <<static>>
		+ register_strategy(ParserStrategy) <<static>>
	}
	interface ParserStrategy  {
		+ parse(File, Deserializer) <<static>>
		+ heuristic(File) : unsigned int <<static>>
	}

	ParserStrategy .> Parser
	ParserStrategy <. Parser

	class CSVParser
	class XMLParser
	class TXTParser

	CSVParser ..|> ParserStrategy
	TXTParser ..|> ParserStrategy
	XMLParser ..|> ParserStrategy

	class Deserializer {
		+ set_target(Museum &)
		+ add_artist(uniq<ArtistData>)
		+ set_rows(unsigned int)
		+ set_cols(unsigned int)
		+ add_type(string, Color, unsigned int)
		+ add_tile(unsigned int x, unsigned int y, uniq<TileData>)
	}

	CSVParser -up-> Deserializer
	XMLParser -up-> Deserializer
	TXTParser -up-> Deserializer

	' ParserStrategy ..> Deserializer
}

rectangle Group_Model as "Model" <<group>> {
	class Canvas {
		+ get_tile(x, y)
		+ set_tile(x, y, TileData)
		- data : CanvasData
		- tiles : Tile[]
	}
	class People {
		+ add_artist(uniq<ArtistData>)
		- artists : Artist[]
	}
	class Museum {
		- people : People
		- canvas : Canvas
	}
	class Tile {
		+ data : TileData
	}
	struct TileData {
		+ type : string
	}
	class Artist {
		+ update()
		--
		- data : ArtistData
	}
	struct ArtistData {
		+ x : float
		+ y : float
		+ vx : float
		+ vy : float
	}
	struct CanvasData {
		+ rows : unsigned int
		+ columns : unsigned int
	}

	Museum --> People
	Museum --> Canvas

	Canvas --> Tile
	People --> Artist

	Tile   -> TileData
	Artist -l> ArtistData
	Canvas -> CanvasData

	' LAYOUT
	Artist -r[hidden] Tile
}

rectangle Group_TileAppearance as "Tile appearance" <<group>> {
	struct Color {
		red : unsigned int
		green : unsigned int
		blue : unsigned int
	}
	class TileAppearance {
		+ get_color(string) : Color <<static>>
		+ register_color(string, Color) <<static>>
	}

	Tile --> Color

	Color <.. TileAppearance
}
rectangle Group_TileBehavior as "Tile behavior" <<group>> {
	interface TileBehaviorStrategy

	class TileBehavior

	together {
		class NullTileBehavior

		class GrayTileBehavior
		class RedTileBehavior
		class BlueTileBehavior
		class YellowTileBehavior

		NullTileBehavior -d[hidden]- GrayTileBehavior
		GrayTileBehavior -d[hidden]- RedTileBehavior
		RedTileBehavior -d[hidden]- BlueTileBehavior
		BlueTileBehavior -d[hidden]- YellowTileBehavior
	}

	TileBehaviorStrategy <|.. NullTileBehavior
	TileBehaviorStrategy <|.. GrayTileBehavior
	TileBehaviorStrategy <|.. RedTileBehavior
	TileBehaviorStrategy <|.. BlueTileBehavior
	TileBehaviorStrategy <|.. YellowTileBehavior

	Tile --> "state" TileBehavior

	TileBehavior .l> TileBehaviorStrategy
	TileBehavior <. TileBehaviorStrategy
}

rectangle Group_Visualization as "Visualization" <<group>> {
	struct Rectangle {
		x : unsigned int
		y : unsigned int
		width : unsigned int
		height : unsigned int
	}
	enum Scancode {
	}

	package SDL2 { }
	class View {
	}
	class ViewController {
		+ update()
	}

	ViewController ..> View
	ViewController <-- View
	View -> SDL2
}

rectangle Group_Commands as "Commands" <<group>> {
	class Command {
		#museum : Museum&
		#view : View&
		#controller : ViewController&
		+Command(museum, view, controller)
		+Command(command : const Command *)
	}

	class MuseumPauseCommand {
		+toggle()
		+set(paused : bool)
	}
	class OpenFileGUICommand {
		+execute()
	}
	class ArtistVisibilityCommand {
		+toggle()
		+set(paused : bool)
	}

	Command <|-u- MuseumPauseCommand
	Command <|-u- OpenFileGUICommand
	Command <|-u- ArtistVisibilityCommand

	Command .d..> Museum
	Command ...d[norank]> View
	Command ...d[norank]> ViewController
}

' PeopleDeserializer <... People
' CanvasDeserializer <... Canvas
' Deserializer       <... Museum

ParserStrategy ..> FileStrategy
' Museum .> Deserializer : friend
Deserializer .> Museum

ViewController -[norank]> Command

main --> Museum
main --[norank]> Deserializer
main --[norank]> View
' DETAIL: main ..[norank]> FileReader
' DETAIL: main ..[norank]> Parser

' LAYOUT
Group_ParsingDeserialization -d[hidden] Group_FileReading
Group_TileBehavior -r[hidden] Group_TileAppearance
Group_Model -r[hidden] Group_ParsingDeserialization
Group_Model -l[hidden] main
' Group_Model -d[hidden] Group_TileBehavior
' Group_Model -d[hidden] Group_TileAppearance

@enduml