// Swift 버전입니다.

import Foundation

class Theater: Equatable {
    static func == (lhs: Theater, rhs: Theater) -> Bool {
        return lhs.name == rhs.name
    }

    private var ticketOffices = [TicketOffice]()
    private var movies = [Movie]()
    let name: String
    init(name: String) {
        self.name = name
    }

    func getPrice(movie: Movie) -> Int? {
        guard movies.contains(movie) else { return nil }
        return movie.price
    }

    func setTicketOffices(_ ticketOffices: [TicketOffice]) {
        self.ticketOffices = ticketOffices
    }

    func setMovies(_ movies: [Movie]) {
        self.movies = movies
    }

    func setTicket(ticketOffice: TicketOffice, count: Int, for movie: Movie) {
        guard ticketOffices.contains(ticketOffice), movies.contains(movie) else { return }
        for _ in stride(from: count, to: 0, by: -1) { ticketOffice.addTicket(Ticket(theater: self, movie: movie)) }
    }

    func setInvitation(audience: Audience, movie: Movie) {
        audience.setInvitation(Invitation(theater: self, movie: movie))
    }

    func enter(audience: Audience) -> Bool {
        guard let ticket = audience.getTicket() else { return false }
        return ticket.isValid(theater: self)
    }
}

struct Movie: Equatable {
    let name: String
    let price: Int
    init(name: String, price: Int) {
        self.name = name
        self.price = price
    }
}

class Ticket {
    let theater: Theater
    let movie: Movie
    private var isEntered = false
    init(theater: Theater, movie: Movie) {
        self.theater = theater
        self.movie = movie
    }

    func isValid(theater: Theater) -> Bool {
        guard !isEntered, theater == self.theater else { return false }
        isEntered = true
        return true
    }

    func getPrice() -> Int {
        return movie.price
    }
}

class Invitation {
    let theater: Theater
    let movie: Movie
    init(theater: Theater, movie: Movie) {
        self.theater = theater
        self.movie = movie
    }
}

class TicketOffice: Equatable {
    static func == (lhs: TicketOffice, rhs: TicketOffice) -> Bool {
        return lhs.theater.name == rhs.theater.name
    }

    let theater: Theater
    private var tickets = [Ticket]()
    private var amount: Int

    init(theater: Theater, amount: Int) {
        self.theater = theater
        self.amount = amount
    }

    func addTicket(_ ticket: Ticket) {
        self.tickets.append(ticket)
    }

    func getTicketWithFee(_ movie: Movie) -> Ticket? {
        guard let idx = tickets.firstIndex(where: { $0.movie == movie }) else { return nil }
        let ticket = tickets.remove(at: idx)
        amount += ticket.getPrice()
        return ticket
    }

    func getTicketWithoutFee(_ movie: Movie) -> Ticket? {
        guard let idx = tickets.firstIndex(where: { $0.movie == movie }) else { return nil }
        return tickets.remove(at: idx)
    }

    func getTicketPrice(_ movie: Movie) -> Int? {
        guard let ticket = tickets.filter({ $0.movie == movie }).first else { return nil }
        return ticket.getPrice()
    }
}

class TicketSeller {
    private var ticketOffice: TicketOffice?
    func setTicketOffice(_ ticketOffice: TicketOffice) {
        self.ticketOffice = ticketOffice
    }

    func getTicket(audience: Audience, movie: Movie) -> Ticket? {
        guard let ticketOffice = self.ticketOffice, let price = ticketOffice.getTicketPrice(movie) else { return nil }
        if let invitation = audience.getInvitation(), invitation.movie == movie, let ticket = ticketOffice.getTicketWithoutFee(movie) {
            audience.removeInvitation()
            return ticket
        }
        if audience.hasAmount(price), let ticket = ticketOffice.getTicketWithFee(movie), audience.minusAmount(price) {
            return ticket
        }
        return nil
    }
}

class Audience {
    private var invitation: Invitation?
    private var ticket: Ticket?

    private var amount: Int
    init(amount: Int) {
        self.amount = amount
    }

    func buyTicket(seller: TicketSeller, movie: Movie) {
        ticket = seller.getTicket(audience: self, movie: movie)
    }

    func getTicket() -> Ticket? {
        return self.ticket
    }

    func hasAmount(_ amount: Int) -> Bool {
        return self.amount >= amount
    }

    func minusAmount(_ amoun: Int) -> Bool {
        guard self.amount >= amount else { return false }
        self.amount -= amount
        return true
    }

    func getInvitation() -> Invitation? {
        return self.invitation
    }
    func setInvitation(_ invitation: Invitation) {
        self.invitation = invitation
    }
    func removeInvitation() {
        self.invitation = nil
    }
}

let cgv = Theater(name: "CGV")
let spiderMan = Movie.init(name: "SpiderMan", price: 10000)
let lionKing = Movie.init(name: "LionKing", price: 9000)
let ticketOffice = TicketOffice(theater: cgv, amount: 0)

let seller = TicketSeller()
seller.setTicketOffice(ticketOffice)

let audience1 = Audience(amount: 8000)
let audience2 = Audience(amount: 15000)

cgv.setTicketOffices([ticketOffice])
cgv.setMovies([spiderMan, lionKing])
cgv.setTicket(ticketOffice: ticketOffice, count: 500, for: spiderMan)
cgv.setTicket(ticketOffice: ticketOffice, count: 300, for: lionKing)
cgv.setInvitation(audience: audience1, movie: lionKing)

audience1.buyTicket(seller: seller, movie: spiderMan)
audience2.buyTicket(seller: seller, movie: lionKing)

let isOK1 = cgv.enter(audience: audience1)
let isOK2 = cgv.enter(audience: audience2)

print(isOK1) // false -> 돈이 없고 invitation을 lionKing 을 받았는데 spiderMan을 보고 싶어함
print(isOK2) // true 돈이 많음