package main

import "fmt"

// Vehicle is the product
type Vehicle interface {
 Brake() string
 Drive() string
}

// VehicleFactory is the abstract factory
type VehicleFactory interface {
 CreateVehicle(vehicleType string) Vehicle
}

// CheapVehicleFactory is a concrete factory producing cheap stuff
type CheapVehicleFactory struct{}

func (f *CheapVehicleFactory) CreateVehicle(vehicleType string) Vehicle {
 switch vehicleType {
 case "Car":
  return &CheapCar{}
 case "Bike":
  return &CheapBike{}
 default:
  return nil
 }
}

// NiceVehicleFactory is a concrete factory producing nice stuff
type NiceVehicleFactory struct{}

func (f *NiceVehicleFactory) CreateVehicle(vehicleType string) Vehicle {
 switch vehicleType {
 case "Car":
  return &NiceCar{}
 case "Bike":
  return &NiceBike{}
 default:
  return nil
 }
}

// CheapCar is a concrete product implementing the Vehicle interface that's not so reliable
type CheapCar struct{}

// NiceCar is a concrete product implementing the Vehicle interface that's more likely to work
type NiceCar struct{}

// CheapBike is what it is
type CheapBike struct{}

// NiceBike is nice
type NiceBike struct{}

func (c *CheapCar) Brake() string {
 return "Squeeeeeeeak..."
}

func (c *NiceCar) Brake() string {
 return "Shhh."
}

func (c *CheapCar) Drive() string {
 return "Vroom poof poof vroom poof poof vroom"
}

func (c *NiceCar) Drive() string {
 return "VROOOOOM"
}

func (b *CheapBike) Brake() string {
 return "iiiiiiiiik"
}

func (b *NiceBike) Brake() string {
 return "(silence)"
}

func (b *CheapBike) Drive() string {
 return "kwik kwik kwik"
}

func (b *NiceBike) Drive() string {
 return "(silence)"
}

func produceVehicles(factory VehicleFactory) {
 car := factory.CreateVehicle("Car")
 fmt.Println("Car:")
 fmt.Println("drive:", car.Drive())
 fmt.Println("stop: ", car.Brake())

 bike := factory.CreateVehicle("Bike")
 fmt.Println("Bike:")
 fmt.Println("ride: ", bike.Drive())
 fmt.Println("brake:", bike.Brake())
}

func main() {
 momsGarage := &CheapVehicleFactory{}
 uncleBobsMansion := &NiceVehicleFactory{}

 fmt.Println("Cheap Vehicles\n-----------------")
 produceVehicles(momsGarage)

 fmt.Println("\nNice Vehicles\n---------------")
 produceVehicles(uncleBobsMansion)

 // Output:
 /*
   Cheap Vehicles
   -----------------
   Car:
   drive: Vroom poof poof vroom poof poof vroom
   stop:  Squeeeeeeeak...
   Bike:
   ride:  kwik kwik kwik
   brake: iiiiiiiiik

   Nice Vehicles
   ---------------
   Car:
   drive: VROOOOOM
   stop:  Shhh.
   Bike:
   ride:  (silence)
   brake: (silence)
 */
}

package main

import "fmt"

// Product interfaces
type Car interface {
 Drive() string
}
type Bicycle interface {
 Ride() string
}

// Concrete products
type MercedesCar struct{}
type BMWCar struct{}
type CannondaleBicycle struct{}
type SpecializedBicycle struct{}

func (t *MercedesCar) Drive() string {
 return "Driving Mercedes"
}
func (t *BMWCar) Drive() string {
 return "Driving BMW"
}
func (t *CannondaleBicycle) Ride() string {
 return "Riding Cannondale"
}
func (t *SpecializedBicycle) Ride() string {
 return "Riding Specialized"
}

// Abstract factory
type VehicleFactory interface {
 CreateCar() Car
 CreateBicycle() Bicycle
}

// Concrete factories
type MercedesFactory struct{}
type BMWFactory struct{}
type SpecializedFactory struct{}

func (t *MercedesFactory) CreateCar() Car {
 return &MercedesCar{}
}

// Let's assume Mercedes make Cannondale bicycles
func (t *MercedesFactory) CreateBicycle() Bicycle {
 return &CannondaleBicycle{}
}

func (t *BMWFactory) CreateCar() Car {
 return &BMWCar{}
}

// Let's assume BMW also makes Specialized bicycles
func (t *BMWFactory) CreateBicycle() Bicycle {
 return &SpecializedBicycle{}
}

// Let's assume Specialized makes its own bicycles
func (t *SpecializedFactory) CreateBicycle() Bicycle {
 return &SpecializedBicycle{}
}

func produceVehicles(factory VehicleFactory) {
 car := factory.CreateCar()
 fmt.Println(car.Drive())

 bicycle := factory.CreateBicycle()
 fmt.Println(bicycle.Ride())
}

func main() {
 mercedesFactory := &MercedesFactory{}
 bmwFactory := &BMWFactory{}

 fmt.Println("Mercedes vehicles:")
 produceVehicles(mercedesFactory)

 fmt.Println("\nBMW vehicles:")
 produceVehicles(bmwFactory)

 // This doesn't work because SpecializedFactory doesn't implement CreateCar()
 // produceVehicles(&SpecializedFactory{})

 // Output:
 /*
  Mercedes vehicles:
  Driving Mercedes
  Riding Cannondale

  BMW vehicles:
  Driving BMW
  Riding Specialized
 */
}

package main

import "fmt"

// Candy is the Product
type Candy struct {
 Sugar     int
 Flavor    string
 Color     string
 Packaging string
}

// CandyBuilder is the abstract Builder interface
type CandyBuilder interface {
 SetSugar(sugar int) CandyBuilder
 SetFlavor(flavor string) CandyBuilder
 SetColor(color string) CandyBuilder
 SetPackaging(packaging string) CandyBuilder
 Build() Candy
}

// SimpleCandyBuilder is a Concrete Builder
type SimpleCandyBuilder struct {
 candy Candy
}

func NewSimpleCandyBuilder() *SimpleCandyBuilder {
 return &SimpleCandyBuilder{candy: Candy{}}
}

func (b *SimpleCandyBuilder) SetSugar(sugar int) CandyBuilder {
 b.candy.Sugar = sugar
 return b
}

func (b *SimpleCandyBuilder) SetFlavor(flavor string) CandyBuilder {
 b.candy.Flavor = flavor
 return b
}

func (b *SimpleCandyBuilder) SetColor(color string) CandyBuilder {
 b.candy.Color = color
 return b
}

func (b *SimpleCandyBuilder) SetPackaging(packaging string) CandyBuilder {
 b.candy.Packaging = packaging
 return b
}

func (b *SimpleCandyBuilder) Build() Candy {
 return b.candy
}

type CandyDirector struct {
 builder CandyBuilder
}

func NewCandyDirector(builder CandyBuilder) *CandyDirector {
 return &CandyDirector{
  builder: builder,
 }
}

// ConstructPeppermintCandy creates a peppermint candy with green packaging.
func (d *CandyDirector) ConstructPeppermintCandy() Candy {
 return d.builder.SetSugar(10).
  SetFlavor("Peppermint").
  SetColor("White").
  SetPackaging("Green").
  Build()
}

// ConstructCaramelCandy creates a caramel candy with yellow packaging.
func (d *CandyDirector) ConstructCaramelCandy() Candy {
 return d.builder.SetSugar(15).
  SetFlavor("Caramel").
  SetColor("Brown").
  SetPackaging("Yellow").
  Build()
}

func main() {
 builder := NewSimpleCandyBuilder()
 director := NewCandyDirector(builder)

 peppermintCandy := director.ConstructPeppermintCandy()
 fmt.Printf("Peppermint Candy: %+v\n", peppermintCandy)

 caramelCandy := director.ConstructCaramelCandy()
 fmt.Printf("Caramel Candy: %+v\n", caramelCandy)

 // Output:
 // Peppermint Candy: {Sugar:10 Flavor:Peppermint Color:White Packaging:Green}
 // Caramel Candy: {Sugar:15 Flavor:Caramel Color:Brown Packaging:Yellow}
}

package main

import "fmt"

// Animal is the prototype interface that all animals must implement
type Animal interface {
 Clone() Animal
 GetInfo() string
}

// Sheep is a concrete prototype that implements the Animal interface
type Sheep struct {
 Name string
 Age  int
}

// Clone creates a new Sheep instance with the same data
func (s *Sheep) Clone() Animal {
 // Create a new Sheep instance with the same data
 return &Sheep{Name: s.Name, Age: s.Age}
}

// GetInfo returns the sheep's name and age
func (s *Sheep) GetInfo() string {
 return fmt.Sprintf("Sheep Name: %s, Age: %d", s.Name, s.Age)
}

// Dog is another concrete prototype that implements the Animal interface
type Dog struct {
 Name  string
 Breed string
}

// Clone creates a new Dog instance with the same data
func (d *Dog) Clone() Animal {
 return &Dog{Name: d.Name, Breed: d.Breed}
}

// GetInfo returns the dog's name and breed
func (d *Dog) GetInfo() string {
 return fmt.Sprintf("Dog Name: %s, Breed: %s", d.Name, d.Breed)
}

type PrototypeRegistry struct {
 items map[string]Animal
}

func NewPrototypeRegistry() *PrototypeRegistry {
 return &PrototypeRegistry{items: make(map[string]Animal)}
}

func (r *PrototypeRegistry) Register(name string, animal Animal) {
 r.items[name] = animal
}

func (r *PrototypeRegistry) Clone(name string) (Animal, error) {
 if animal, exists := r.items[name]; exists {
  return animal.Clone(), nil
 }
 return nil, fmt.Errorf("prototype not found: %s", name)
}

func main() {
 registry := NewPrototypeRegistry()
 registry.Register("sheep", &Sheep{Name: "Dolly", Age: 4})
 registry.Register("dog", &Dog{Name: "Fido", Breed: "Bulldog"})

 clonedAnimal, err := registry.Clone("sheep")
 if err != nil {
  fmt.Println("Error cloning sheep:", err)
  return
 }

 clonedSheep, ok := clonedAnimal.(*Sheep)
 if !ok {
  fmt.Println("Type assertion failed: not a *Sheep")
  return
 }
 clonedSheep.Name = "Molly"
 fmt.Println(clonedSheep.GetInfo())

 clonedAnimal2, err := registry.Clone("dog")
 if err != nil {
  fmt.Println("Error cloning dog:", err)
  return
 }

 clonedDog, ok := clonedAnimal2.(*Dog)
 if !ok {
  fmt.Println("Type assertion failed: not a *Dog")
  return
 }
 clonedDog.Name = "Rex"
 fmt.Println(clonedDog.GetInfo())

 // Output:
 /*
  Sheep Name: Molly, Age: 4
  Dog Name: Rex, Breed: Bulldog
 */
}

package main

import (
 "fmt"
 "sync"
)

type ConfigurationData struct {
 DatabaseURL string
}

// ConfigurationManager is a singleton that holds the configuration for the application.
type ConfigurationManager struct {
 config *ConfigurationData
}

var (
 instance *ConfigurationManager
 once     sync.Once
)

// GetInstance returns the singleton instance of the ConfigurationManager.
func GetInstance() *ConfigurationManager {
 once.Do(func() {
  instance = &ConfigurationManager{
   config: &ConfigurationData{
    DatabaseURL: "localhost:4321", // Default value
   },
  }
 })
 return instance
}

// UpdateConfig updates configuration if needed
func (m *ConfigurationManager) UpdateConfig(newConfig *ConfigurationData) {
 m.config = newConfig
}

func main() {
 config1 := GetInstance()
 config2 := GetInstance()

 fmt.Println(config1 == config2) // true
}

package main

import "fmt"

type Outlet interface {
 InsertInOutlet() string
}

type Pluggable interface {
 InsertInUSOutlet() string
}

type USPlug struct{}

type USPlugAdapter struct {
 usPlug Pluggable
}

func (plug *USPlug) InsertInUSOutlet() string {
 return "Inserted in US Outlet"
}

func NewUSPlugAdapter(usPlug Pluggable) *USPlugAdapter {
 return &USPlugAdapter{usPlug: usPlug}
}

func (adapter *USPlugAdapter) InsertInOutlet() string {
 return adapter.usPlug.InsertInUSOutlet() + ", adapted to fit an Outlet"
}

func ChargeDevice(outlet Outlet) string {
 return outlet.InsertInOutlet()
}

func main() {
 usPlug := &USPlug{}
 adaptedPlug := NewUSPlugAdapter(usPlug)

 result := ChargeDevice(adaptedPlug)
 fmt.Println(result) // Inserted in US Outlet, adapted to fit an Outlet
}

package main

import "fmt"

// The Device interface (the abstraction) defines the operations that all
// concrete device implementations must support.
type Device interface {
 TurnOn()
 TurnOff()
 IsEnabled() bool
 SetVolume(volume int)
 GetVolume() int
}

// TV and Radio are concrete implementations of the Device interface.
type TV struct {
 isEnabled bool
}

func (t *TV) TurnOn() {
 t.isEnabled = true
}

func (t *TV) TurnOff() {
 t.isEnabled = false
}

func (t *TV) IsEnabled() bool {
 return t.isEnabled
}

// SetVolume for TV
func (t *TV) SetVolume(volume int) {
 fmt.Printf("TV volume set to %d\n", volume)
}

// GetVolume for TV
func (t *TV) GetVolume() int {
 return 50 // Placeholder
}

type Radio struct {
 isEnabled bool
}

func (r *Radio) TurnOn() {
 r.isEnabled = true
}

func (r *Radio) TurnOff() {
 r.isEnabled = false
}

func (r *Radio) IsEnabled() bool {
 return r.isEnabled
}

// SetVolume for Radio
func (r *Radio) SetVolume(volume int) {
 fmt.Printf("🔉 Radio volume set to %d\n", volume)
}

// GetVolume for Radio
func (r *Radio) GetVolume() int {
 return 30 // Placeholder
}

type RemoteControl struct {
 device Device
 name   string
}

func NewRemoteControl(device Device, name string) *RemoteControl {
 fmt.Println("NewRemoteControl", name)
 return &RemoteControl{device: device, name: name}
}

func (r *RemoteControl) TogglePower() {
 if r.device.IsEnabled() {
  fmt.Println(r.name, "🔴 turning off")
  r.device.TurnOff()
 } else {
  fmt.Println(r.name, "🟢 turning on")
  r.device.TurnOn()
 }
}

type AdvancedRemoteControl struct {
 *RemoteControl // Embedding RemoteControl to inherit its methods
}

func NewAdvancedRemoteControl(device Device, name string) *AdvancedRemoteControl {
 return &AdvancedRemoteControl{RemoteControl: NewRemoteControl(device, name)}
}

func (a *AdvancedRemoteControl) SetDeviceVolume(volume int) {
 a.device.SetVolume(volume)
}

func NewTV() *TV {
 return &TV{isEnabled: false}
}

func NewRadio() *Radio {
 return &Radio{isEnabled: false}
}

func main() {
 // TV without advanced remote
 tv := NewTV()
 remote := NewRemoteControl(tv, "Samsung TV")
 remote.TogglePower() // Turns TV on
 remote.TogglePower() // Turns TV off

 // Radio with advanced remote
 radio := NewRadio()
 radioRemote := NewAdvancedRemoteControl(radio, "Sony Radio")
 radioRemote.TogglePower()
 radioRemote.SetDeviceVolume(30)
 radioRemote.TogglePower()

 // Output:
 /*
  NewRemoteControl Samsung TV
  Samsung TV turning on
  Samsung TV turning off
  NewRemoteControl Sony Radio
  Sony Radio turning on
  Radio volume set to 30
  Sony Radio set volume to 30
  Sony Radio turning off
 */
}

package main

import (
 "fmt"
 "strings"
)

// Command is the component interface that all commands must implement.
type Command interface {
 Execute()
 Undo()
}

type Document struct {
 content string
}

// WriteCommand is a leaf that implements the Command component interface.
type WriteCommand struct {
 document *Document
 addition string
}

// SaveCommand is another leaf.
type SaveCommand struct {
 document *Document
}

func (w *WriteCommand) Execute() {
 w.document.content += w.addition
 fmt.Printf("Document after writing: %s\n", w.document.content)
}

func (w *WriteCommand) Undo() {
 fmt.Printf("Undo writing: %s\n", w.addition)
 w.document.content = strings.TrimSuffix(w.document.content, w.addition)
}

func (s *SaveCommand) Execute() {
 fmt.Printf("Document saved: %s\n", s.document.content)
}

func (s *SaveCommand) Undo() {
 fmt.Println("Restore to the last saved point...")
}

type CommandManager struct {
 history []Command
}

func (m *CommandManager) ExecuteCommand(cmd Command) {
 cmd.Execute()
 m.history = append(m.history, cmd)
}

func (m *CommandManager) Undo() {
 if len(m.history) == 0 {
  return
 }
 cmd := m.history[len(m.history)-1]
 cmd.Undo()
 m.history = m.history[:len(m.history)-1]
}

// CompositeCommand is a composite that implements the Command component interface.
type CompositeCommand struct {
 commands []Command
}

func (c *CompositeCommand) Execute() {
 for _, cmd := range c.commands {
  cmd.Execute()
 }
}

func (c *CompositeCommand) Undo() {
 for i := len(c.commands) - 1; i >= 0; i-- {
  c.commands[i].Undo()
 }
}

func (c *CompositeCommand) AddCommand(cmd Command) {
 c.commands = append(c.commands, cmd)
}

func main() {
 doc := &Document{}
 write1 := &WriteCommand{document: doc, addition: "Hello "}
 write2 := &WriteCommand{document: doc, addition: "World"}
 save := &SaveCommand{document: doc}

 compositeCommand := &CompositeCommand{}
 compositeCommand.AddCommand(write1)
 compositeCommand.AddCommand(write2)
 compositeCommand.AddCommand(save)

 commandManager := &CommandManager{}
 commandManager.ExecuteCommand(compositeCommand)

 fmt.Println("\nUndoing Composite Command:")
 commandManager.Undo()

 fmt.Printf("\nFinal Document Content: %s\n", doc.content)

 // Output:
 /*
  Document after writing: Hello
  Document after writing: Hello World
  Document saved: Hello World

  Undoing Composite Command:
  Restore to the last saved point...
  Undo writing: World
  Undo writing: Hello

  Final Document Content:
 */
}

package main

import "fmt"

// Component is the common interface for both the concrete component and the
// decorators. It can have multiple layers of decorators.
type Component interface {
 Operation() string
}

// ConcreteComponent is a concrete component that implements the Component
// interface, defining all the operations that can be altered by decorators.
type ConcreteComponent struct{}

func (c *ConcreteComponent) Operation() string {
 return "ConcreteComponent"
}

// Decorator is a base decorator class. It implements the Component interface
// and has a field for storing a reference to a wrapped object. The default
// implementation of the wrapped object does the actual work, while the
// decorator merely delegates to the wrapped object.
type Decorator struct {
 component Component
}

// Operation Decorator delegates all work to the wrapped component.
func (d *Decorator) Operation() string {
 return d.component.Operation()
}

// ConcreteDecoratorA calls the wrapped object and alter its result in some way.
type ConcreteDecoratorA struct {
 Decorator
}

// Operation Decorators may call parent implementation of the operation, instead of
// calling the wrapped object directly, simplifying extension of decorator classes.
func (d *ConcreteDecoratorA) Operation() string {
 return "ConcreteDecoratorA(" + d.Decorator.Operation() + " + AddedBehaviorA)"
}

func NewConcreteDecoratorA(component Component) *ConcreteDecoratorA {
 return &ConcreteDecoratorA{Decorator{component: component}}
}

type ConcreteDecoratorB struct {
 Decorator
}

func (d *ConcreteDecoratorB) Operation() string {
 pre := "PreBehaviorB | "
 base := d.Decorator.Operation() // Delegate to base Operation
 post := " | PostBehaviorB"
 return pre + "ConcreteDecoratorB(" + base + ")" + post
}

func NewConcreteDecoratorB(component Component) *ConcreteDecoratorB {
 return &ConcreteDecoratorB{Decorator{component: component}}
}

func main() {
 var decoratedComponent Component = &ConcreteComponent{}

 decoratedComponent = NewConcreteDecoratorA(decoratedComponent)
 decoratedComponent = NewConcreteDecoratorB(decoratedComponent)

 fmt.Println(decoratedComponent.Operation())
 // Output:
 // PreBehaviorB | ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent + AddedBehaviorA)) | PostBehaviorB
}

package main

// Example of a facade pattern

import (
 "fmt"
 "strings"
)

// TV is subsystem 1
type TV struct {
 isOn bool
}

func (t *TV) TurnOn() (string, error) {
 if t.isOn {
  return "", fmt.Errorf("❌ TV is already on")
 }
 t.isOn = true
 return "TV is on", nil
}

func (t *TV) TurnOff() (string, error) {
 if !t.isOn {
  return "", fmt.Errorf("❌ TV is already off")
 }
 t.isOn = false
 return "TV is off", nil
}

// SoundSystem is subsystem 2
type SoundSystem struct {
 isOn bool
}

func (s *SoundSystem) TurnOn() (string, error) {
 if s.isOn {
  return "", fmt.Errorf("❌ SoundSystem is already on")
 }
 s.isOn = true
 return "SoundSystem is on", nil
}

func (s *SoundSystem) TurnOff() (string, error) {
 if !s.isOn {
  return "", fmt.Errorf("❌ SoundSystem is already off")
 }
 s.isOn = false
 return "SoundSystem is off", nil
}

// DVDPlayer is subsystem 3
type DVDPlayer struct {
 isOn bool
}

func (d *DVDPlayer) Play() (string, error) {
 if d.isOn {
  return "", fmt.Errorf("❌ DVD is already playing")
 }
 d.isOn = true
 return "DVD is playing", nil
}

func (d *DVDPlayer) Stop() (string, error) {
 if !d.isOn {
  return "", fmt.Errorf("❌ DVD is already stopped")
 }
 d.isOn = false
 return "DVD stopped", nil
}

// HomeTheaterFacade provides a simplified interface to a complex subsystem
type HomeTheaterFacade struct {
 tv          *TV
 soundSystem *SoundSystem
 dvdPlayer   *DVDPlayer
}

// NewHomeTheaterFacade is a constructor for HomeTheaterFacade
func NewHomeTheaterFacade(tv *TV, soundSystem *SoundSystem, dvdPlayer *DVDPlayer) *HomeTheaterFacade {
 return &HomeTheaterFacade{
  tv:          tv,
  soundSystem: soundSystem,
  dvdPlayer:   dvdPlayer,
 }
}

// WatchMovie is a facade method
func (h *HomeTheaterFacade) WatchMovie() (string, error) {
 if h.tv == nil || h.soundSystem == nil || h.dvdPlayer == nil {
  return "", fmt.Errorf("❌ home theater is not properly set up")
 }

 response := NewOperationResponse()
 tvResponse, tvErr := h.tv.TurnOn()
 response.AddResponse(tvResponse, tvErr)
 soundSystemResponse, soundSystemErr := h.soundSystem.TurnOn()
 response.AddResponse(soundSystemResponse, soundSystemErr)
 dvdResponse, dvdErr := h.dvdPlayer.Play()
 response.AddResponse(dvdResponse, dvdErr)
 return response.String(), nil
}

// StopMovie is a facade method
func (h *HomeTheaterFacade) StopMovie() string {
 response := NewOperationResponse()
 dvdResponse, dvdErr := h.dvdPlayer.Stop()
 response.AddResponse(dvdResponse, dvdErr)
 soundSystemResponse, soundSystemErr := h.soundSystem.TurnOff()
 response.AddResponse(soundSystemResponse, soundSystemErr)
 tvResponse, tvErr := h.tv.TurnOff()
 response.AddResponse(tvResponse, tvErr)
 return response.String()
}

type OperationResponse struct {
 Responses []string
 Errors    []error
}

func NewOperationResponse() *OperationResponse {
 return &OperationResponse{}
}

func (o *OperationResponse) AddResponse(response string, err error) {
 if response != "" {
  o.Responses = append(o.Responses, response)
 }
 if err != nil {
  o.Errors = append(o.Errors, err)
 }
}

func (o *OperationResponse) String() string {
 // Combine all responses and errors into a single string, don't display nil errors
 var responseStrings []string
 responseStrings = append(responseStrings, o.Responses...)
 return strings.Join(responseStrings, "\n")
}

func mapErrorsToStrings(errors []error) []string {
 var errorStrings []string
 for _, err := range errors {
  errorStrings = append(errorStrings, err.Error())
 }
 return errorStrings
}

func main() {
 tv := &TV{}
 soundSystem := &SoundSystem{}
 dvdPlayer := &DVDPlayer{}

 faultyHomeTheater := NewHomeTheaterFacade(tv, soundSystem, nil)
 fmt.Println("Trying to watch a movie with a faulty home theater...")
 faultyMovie, err := faultyHomeTheater.WatchMovie()
 if err != nil {
  fmt.Println(err)
 } else {
  fmt.Println(faultyMovie)
 }

 homeTheater := NewHomeTheaterFacade(tv, soundSystem, dvdPlayer)
 fmt.Println("About to watch a movie with a properly set up home theater...")
 movie, err := homeTheater.WatchMovie()
 if err != nil {
  return
 }
 fmt.Println(movie)

 fmt.Println("Someone tries to turn on the TV while it's already on...")
 _, err = tv.TurnOn()
 if err != nil {
  fmt.Println(err)
 }

 fmt.Println("Trying to start the movie again while it's already playing...")
 watchMovie, err := homeTheater.WatchMovie()
 if err != nil {
  return
 }
 fmt.Println(watchMovie)
 fmt.Println("Stopping the movie...")
 homeTheater.StopMovie()
 fmt.Println("Trying to stop the movie again while it's already stopped...")
 homeTheater.StopMovie()

 // Output:
 /*
  Trying to watch a movie with a faulty home theater...
  ❌ home theater is not properly set up
  About to watch a movie with a properly set up home theater...
  TV is on
  SoundSystem is on
  DVD is playing
  Someone tries to turn on the TV while it's already on...
  ❌ TV is already on
  Trying to start the movie again while it's already playing...
  Stopping the movie...
  Trying to stop the movie again while it's already stopped...
 */
}

package main

import (
 "fmt"
 "strings"
)

// TextStyle is the flyweight interface
type TextStyle interface {
 ApplyStyle(text string) string
}

// BoldStyle is a concrete flyweight
type BoldStyle struct{}

func (b *BoldStyle) ApplyStyle(text string) string {
 return "**" + text + "**"
}

// UrgentStyle is a concrete flyweight
type UrgentStyle struct{}

func (u *UrgentStyle) ApplyStyle(text string) string {
 return "‼️ " + text + " ‼️"
}

// ItalicStyle is a concrete flyweight
type ItalicStyle struct{}

func (i *ItalicStyle) ApplyStyle(text string) string {
 return "_" + text + "_"
}

// BulletStyle is a concrete flyweight
type BulletStyle struct{}

func (b *BulletStyle) ApplyStyle(text string) string {
 return "* " + text
}

// StyleFactory is the flyweight factory
type StyleFactory struct {
 styles          map[string]TextStyle
 compositeStyles map[string]*CompositeStyle // cache for composite styles
}

// NewStyleFactory is the flyweight factory constructor
func NewStyleFactory() *StyleFactory {
 return &StyleFactory{
  styles:          make(map[string]TextStyle),
  compositeStyles: make(map[string]*CompositeStyle),
 }
}

func (f *StyleFactory) GetStyle(styleName string) (TextStyle, error) {
 if style, exists := f.styles[styleName]; exists {
  return style, nil
 }

 var style TextStyle
 switch styleName {
 case "bold":
  style = &BoldStyle{}
 case "italic":
  style = &ItalicStyle{}
 case "bullet":
  style = &BulletStyle{}
 default:
  return nil, fmt.Errorf("unknown style: %s", styleName)
 }

 f.styles[styleName] = style
 return style, nil
}

// Extend with the Composite pattern to get multiple styles applied to a text

// CompositeStyle is the composite class
type CompositeStyle struct {
 styles []TextStyle
}

// NewCompositeStyle is the composite constructor
func NewCompositeStyle(styles ...TextStyle) *CompositeStyle {
 return &CompositeStyle{styles: styles}
}

// ApplyStyle is the composite method
func (c *CompositeStyle) ApplyStyle(text string) string {
 for _, style := range c.styles {
  text = style.ApplyStyle(text)
 }
 return text
}

// AddStyle is the composite method
func (c *CompositeStyle) AddStyle(style TextStyle) {
 c.styles = append(c.styles, style)
}

func (f *StyleFactory) GetCompositeStyle(styleNames ...string) TextStyle {
 key := strings.Join(styleNames, "+") // Create a unique key for the combination

 if composite, exists := f.compositeStyles[key]; exists {
  return composite
 }

 var composite = NewCompositeStyle()
 for _, name := range styleNames {
  style, _ := f.GetStyle(name) // Handle error as appropriate
  composite.AddStyle(style)
 }

 f.compositeStyles[key] = composite
 return composite
}

type ConditionalStyle struct {
 condition func(string) bool
 style     TextStyle
}

func NewConditionalStyle(condition func(string) bool, style TextStyle) *ConditionalStyle {
 return &ConditionalStyle{condition: condition, style: style}
}

func (c *ConditionalStyle) ApplyStyle(text string) string {
 if c.condition(text) {
  return c.style.ApplyStyle(text)
 }
 return text
}

func main() {
 factory := NewStyleFactory()

 boldStyle, _ := factory.GetStyle("bold")
 fmt.Println(boldStyle.ApplyStyle("Hello"))

 italicStyle, _ := factory.GetStyle("italic")
 fmt.Println(italicStyle.ApplyStyle("Go!"))

 // Reusing flyweights
 anotherBold, _ := factory.GetStyle("bold")
 fmt.Println(anotherBold.ApplyStyle("Flyweight bold"))

 bulletStyle, _ := factory.GetStyle("bullet")
 fmt.Println(bulletStyle.ApplyStyle("Flyweight list"))

 // Composite styles
 italicBulletStyle := factory.GetCompositeStyle("italic", "bullet")
 fmt.Println(italicBulletStyle.ApplyStyle("Italic bullet"))
 bulletItalicStyle := factory.GetCompositeStyle("bullet", "italic")
 fmt.Println(bulletItalicStyle.ApplyStyle("Bullet italic that's incorrect..."))

 // Apply bold style only if the text contains "important"
 importantCondition := func(text string) bool {
  return strings.Contains(text, "important")
 }
 importantBoldStyle := NewConditionalStyle(importantCondition, &BoldStyle{})

 // Apply urgent style to text that contains "urgent"
 urgentCondition := func(text string) bool {
  return strings.Contains(text, "urgent")
 }
 urgentStyle := NewConditionalStyle(urgentCondition, &UrgentStyle{})

 fmt.Println(importantBoldStyle.ApplyStyle("This is important and should be bold"))
 fmt.Println(urgentStyle.ApplyStyle("This is important but not bold"))
 fmt.Println(urgentStyle.ApplyStyle("This is urgent"))
 fmt.Println(importantBoldStyle.ApplyStyle("This is urgent but not emphasized"))

 // Output:
 /*
  **Hello**
  _Go!_
  **Flyweight bold**
  * Flyweight list
  * _Italic bullet_
  _* Bullet italic that's incorrect..._
  **This is important and should be bold**
  This is important but not bold
  ‼️ This is urgent ‼️
  This is urgent but not emphasized
 */
}

package main

import "fmt"

// RealDocument is the real object that the proxy will represent
type RealDocument struct {
 content string
}

type Displayable interface {
 Display() string
}

type Editable interface {
 Edit(newContent string)
}

// Display is the method that the proxy and the real object both implement, implementing the Displayable interface
func (d *RealDocument) Display() string {
 return "Displaying Document: " + d.content
}

// NewRealDocument is a factory method that creates a new RealDocument
func NewRealDocument(content string) *RealDocument {
 return &RealDocument{content: content}
}

// ProtectedDocument is the proxy object that will control access to the real object
type ProtectedDocument struct {
 content  string
 document *RealDocument
 userRole string
}

// Display is the version that the proxy implements
func (p *ProtectedDocument) Display() string {
 fmt.Printf("Access attempt by %s role\n", p.userRole)
 if p.userRole != "admin" {
  fmt.Println("❌ Access Denied: Insufficient permissions")
  return "Access Denied"
 }
 fmt.Println("✅ Document access granted")
 if p.document == nil {
  fmt.Println("⌛ Loading document content...")
  p.document = NewRealDocument(p.content)
 }
 return p.document.Display()
}

// NewProtectedDocument is a factory method that creates a new ProtectedDocument
func NewProtectedDocument(content string, userRole string) *ProtectedDocument {
 return &ProtectedDocument{content: content, userRole: userRole}
}

func ShowDocument(doc Displayable) {
 fmt.Println(doc.Display())
}

func main() {
 doc := NewRealDocument("Top secret stuff.")

 adminProxy := NewProtectedDocument(doc.content, "admin")
 ShowDocument(adminProxy)

 userProxy := NewProtectedDocument(doc.content, "read-only")
 ShowDocument(userProxy)

 // Whoever has access to the real object can bypass the proxy
 fmt.Println("By-passing the proxy:")
 ShowDocument(doc)

 // Output:
 /*
  Access attempt by admin role
  ✅ Document access granted
  ⌛ Loading document content...
  Displaying Document: Top secret stuff.
  Access attempt by read-only role
  ❌ Access Denied: Insufficient permissions
  Access Denied
  By-passing the proxy:
  Displaying Document: Top secret stuff.
 */
}

package main

import "fmt"

// BaseLogger is the base struct for all loggers
type BaseLogger struct {
 next Logger
}

// Logger is the interface that all loggers must implement
type Logger interface {
 Log(message string, severity int)
 SetNext(logger Logger)
}

// Different types of log levels
const (
 INFO  = 1
 DEBUG = 2
 ERROR = 3
)

func (l *BaseLogger) SetNext(next Logger) {
 l.next = next
}

func (l *BaseLogger) Next(message string, severity int) {
 if l.next != nil {
  l.next.Log(message, severity)
 }
}

type LoggerImpl struct {
 BaseLogger
 levels map[int]bool // Map to hold allowed log levels
}

func NewLogger(levels ...int) *LoggerImpl {
 levelMap := make(map[int]bool)
 for _, level := range levels {
  levelMap[level] = true
 }
 return &LoggerImpl{levels: levelMap}
}

func (l *LoggerImpl) Log(message string, severity int) {
 if l.levels[severity] {
  fmt.Printf("[%s] %s\n", severityToString(severity), message)
  return
 }
 l.Next(message, severity)
}

func severityToString(severity int) string {
 switch severity {
 case INFO:
  return "INFO"
 case DEBUG:
  return "DEBUG"
 case ERROR:
  return "ERROR"
 default:
  return "UNKNOWN"
 }
}

// DefaultLogger is a logger that logs all unhandled messages
type DefaultLogger struct{}

// Log logs the message and severity level for all unhandled messages
func (l *DefaultLogger) Log(message string, severity int) {
 fmt.Printf("[DEFAULT] %s (severity: %d)\n", message, severity)
}

// SetNext does nothing for the default logger
func (l *DefaultLogger) SetNext(next Logger) {
 // default catch-all handler with no next logger
}

func BuildChain(loggers ...Logger) Logger {
 for i := 0; i < len(loggers)-1; i++ {
  loggers[i].SetNext(loggers[i+1])
 }
 return loggers[0] // Return the head of the chain
}

func main() {
 infoLogger := NewLogger(INFO)
 debugLogger := NewLogger(DEBUG)
 errorLogger := NewLogger(ERROR)
 defaultLogger := &DefaultLogger{}

 // Build the chain
 headLogger := BuildChain(debugLogger, infoLogger, errorLogger, defaultLogger)

 // Test the chain
 headLogger.Log("Info message", INFO)
 headLogger.Log("Debug message", DEBUG)
 headLogger.Log("Error message", ERROR)
 headLogger.Log("Unhandled severity message", 0)

 // Output:
 /*
  [INFO] Info message
  [DEBUG] Debug message
  [ERROR] Error message
  [DEFAULT] Unhandled severity message (severity: 0)
 */
}

package main

import "fmt"

// Command is the command interface: Redo() is implicit
type Command interface {
 Execute()
 Undo()
}

// BankAccount is the receiver
type BankAccount struct {
 Balance    float64
 Difference float64
 Operation  string
}

// DepositCommand and WithdrawCommand are the concrete commands
type DepositCommand struct {
 account *BankAccount
 amount  float64
}

// Execute adds the amount to the account balance
func (d *DepositCommand) Execute() {
 d.account.Balance += d.amount
 d.account.Difference = d.amount
 d.account.Operation = "deposit"
}

type WithdrawCommand struct {
 account *BankAccount
 amount  float64
}

// Execute subtracts the amount from the account balance
func (w *WithdrawCommand) Execute() {
 if w.account.Balance >= w.amount {
  w.account.Balance -= w.amount
  w.account.Difference = w.amount
 } else {
  w.account.Difference = 0
 }
 w.account.Operation = "withdrawal"
}

// Undo reverses the DepositCommand operation
func (d *DepositCommand) Undo() {
 d.account.Balance -= d.amount
 d.account.Difference = d.amount
 d.account.Operation = "undo deposit"
}

// Undo reverses the WithdrawCommand operation
func (w *WithdrawCommand) Undo() {
 w.account.Balance += w.amount
 w.account.Difference = w.amount
 w.account.Operation = "undo withdrawal"
}

// CommandManager is the invoker
type CommandManager struct {
 history   []Command
 redoStack []Command
}

// ExecuteCommand adds the command to the history and executes it
func (cm *CommandManager) ExecuteCommand(cmd Command) {
 cmd.Execute()
 cm.history = append(cm.history, cmd)
}

// Undo reverses the last command
func (cm *CommandManager) Undo() {
 if len(cm.history) == 0 {
  return
 }
 cmd := cm.history[len(cm.history)-1]
 cmd.Undo()
 cm.history = cm.history[:len(cm.history)-1] // Remove the last command from history
 cm.redoStack = append(cm.redoStack, cmd)    // Add it to the redo stack
}

// Redo re-executes the last undone command
func (cm *CommandManager) Redo() {
 if len(cm.redoStack) == 0 {
  return
 }
 cmd := cm.redoStack[len(cm.redoStack)-1]
 cmd.Execute()
 cm.redoStack = cm.redoStack[:len(cm.redoStack)-1] // Remove the last command from redoStack
 cm.history = append(cm.history, cmd)              // Add it back to the history
}

// PrintSummary shows the account balance and the difference after the operation
func (b *BankAccount) PrintSummary() {
 if b.Operation == "" {
  fmt.Printf("Account balance: $%.2f\n", b.Balance)
  return
 }

 if b.Operation == "withdrawal" && b.Difference == 0 {
  fmt.Printf("Withdrawal not successful. Account balance: $%.2f\n", b.Balance)
  return
 }

 if b.Operation == "deposit" && b.Difference == 0 {
  fmt.Printf("Deposit not successful. Account balance: $%.2f\n", b.Balance)
  return
 }

 if b.Operation == "withdrawal" {
  fmt.Printf("Account balance after %s: $%.2f ($%.2f - $%.2f)\n", b.Operation, b.Balance, b.Balance+b.Difference, b.Difference)
  return
 }

 if b.Operation == "deposit" {
  fmt.Printf("Account balance after %s: $%.2f ($%.2f + $%.2f)\n", b.Operation, b.Balance, b.Balance-b.Difference, b.Difference)
  return
 }

 if b.Operation == "undo withdrawal" {
  fmt.Printf("Account balance after %s: $%.2f ($%.2f + $%.2f)\n", b.Operation, b.Balance, b.Balance-b.Difference, b.Difference)
  return
 }

 if b.Operation == "undo deposit" {
  fmt.Printf("Account balance after %s: $%.2f ($%.2f - $%.2f)\n", b.Operation, b.Balance, b.Balance+b.Difference, b.Difference)
  return
 }
}

func main() {
 account := &BankAccount{Balance: 100.0}
 manager := CommandManager{}

 deposit := &DepositCommand{account: account, amount: 50}
 withdraw := &WithdrawCommand{account: account, amount: 30}

 account.PrintSummary()

 manager.ExecuteCommand(deposit)
 account.PrintSummary()

 manager.ExecuteCommand(withdraw)
 account.PrintSummary()

 fmt.Println("Undoing the last operation...")
 manager.Undo()
 account.PrintSummary()

 fmt.Println("Redoing the last operation...")
 manager.Redo()
 account.PrintSummary()

 fmt.Println("Undoing the last operation...")
 manager.Undo()
 account.PrintSummary()

 fmt.Println("Undoing the last operation...")
 manager.Undo()
 account.PrintSummary()

 // Output:
 /*
  Account balance: $100.00
  Account balance after deposit: $150.00 ($100.00 + $50.00)
  Account balance after withdrawal: $120.00 ($150.00 - $30.00)
  Undoing the last operation...
  Account balance after undo withdrawal: $150.00 ($120.00 + $30.00)
  Redoing the last operation...
  Account balance after withdrawal: $120.00 ($150.00 - $30.00)
  Undoing the last operation...
  Account balance after undo withdrawal: $150.00 ($120.00 + $30.00)
  Undoing the last operation...
  Account balance after undo deposit: $100.00 ($150.00 - $50.00)
 */
}