Design a Movie Ticket Booking System

public class City
{
    public int Id { get; set; }
    public string Name { get; set; }
    public List<Cinema> Cinemas { get; set; }
}

public class Cinema
{
    public int Id { get; set; }
    public string Name { get; set; }
    public City City { get; set; }
    public List<CinemaHall> Halls { get; set; }
}

public class CinemaHall
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int TotalSeats { get; set; }
    public Cinema Cinema { get; set; }
    public List<Show> Shows { get; set; }
}

public class Movie
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Description { get; set; }
    public int DurationInMinutes { get; set; }
    public string Language { get; set; }
    public DateTime ReleaseDate { get; set; }
    public string Genre { get; set; }
    public List<Show> Shows { get; set; }
}

public class Show
{
    public int Id { get; set; }
    public DateTime StartTime { get; set; }
    public DateTime EndTime { get; set; }
    public CinemaHall CinemaHall { get; set; }
    public Movie Movie { get; set; }
    public List<Seat> Seats { get; set; }
}

public class Seat
{
    public int Id { get; set; }
    public int RowNumber { get; set; }
    public int ColumnNumber { get; set; }
    public SeatType Type { get; set; }
    public Show Show { get; set; }
}

public class Booking
{
    public int Id { get; set; }
    public int NumberOfSeats { get; set; }
    public DateTime Timestamp { get; set; }
    public BookingStatus Status { get; set; }
    public Show Show { get; set; }
    public User User { get; set; }
    public List<Seat> Seats { get; set; }
    public Payment Payment { get; set; }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }
    public List<Booking> Bookings { get; set; }
}

public class Payment
{
    public int Id { get; set; }
    public decimal Amount { get; set; }
    public DateTime Timestamp { get; set; }
    public PaymentStatus Status { get; set; }
    public PaymentMethod Method { get; set; }
    public Booking Booking { get; set; }
    public Coupon AppliedCoupon { get; set; }
}

public class Coupon
{
    public int Id { get; set; }
    public string Code { get; set; }
    public decimal Discount { get; set; }
    public DateTime ExpirationDate { get; set; }
}

public enum SeatType
{
    Regular,
    Premium,
    Accessible
}

public enum BookingStatus
{
    Pending,
    Confirmed,
    Cancelled
}

public enum PaymentStatus
{
    Pending,
    Completed,
    Failed,
    Refunded
}

public enum PaymentMethod
{
    CreditCard,
    Cash
}

public interface IMovieService
{
    List<Movie> SearchMovies(string title, string language, string genre, DateTime? releaseDate, string cityName);
    List<Cinema> GetCinemasShowingMovie(int movieId, int cityId);
    List<Show> GetShowsForMovieAndCinema(int movieId, int cinemaId);
}

public interface IBookingService
{
    Booking CreateBooking(int userId, int showId, List<int> seatIds);
    void CancelBooking(int bookingId);
    Booking GetBookingDetails(int bookingId);
}

public interface IPaymentService
{
    Payment ProcessPayment(int bookingId, PaymentMethod method, string couponCode = null);
    void RefundPayment(int paymentId);
}

public interface ISeatAllocationService
{
    List<Seat> GetAvailableSeats(int showId);
    bool ReserveSeats(int showId, List<int> seatIds, int userId);
    void ReleaseSeats(int showId, List<int> seatIds);
}

public interface INotificationService
{
    void SendNewMovieNotification(Movie movie);
    void SendBookingConfirmation(Booking booking);
    void SendBookingCancellation(Booking booking);
}

public class BookingService : IBookingService
{
    private readonly ISeatAllocationService _seatAllocationService;
    private readonly IPaymentService _paymentService;
    private readonly INotificationService _notificationService;

    public BookingService(ISeatAllocationService seatAllocationService, 
                          IPaymentService paymentService, 
                          INotificationService notificationService)
    {
        _seatAllocationService = seatAllocationService;
        _paymentService = paymentService;
        _notificationService = notificationService;
    }

    public Booking CreateBooking(int userId, int showId, List<int> seatIds)
    {
        // Use a transaction to ensure atomicity
        using (var transaction = new TransactionScope())
        {
            // Check if seats are available and reserve them
            if (!_seatAllocationService.ReserveSeats(showId, seatIds, userId))
            {
                throw new InvalidOperationException("Selected seats are not available.");
            }

            // Create the booking
            var booking = new Booking
            {
                UserId = userId,
                ShowId = showId,
                NumberOfSeats = seatIds.Count,
                Timestamp = DateTime.UtcNow,
                Status = BookingStatus.Pending,
                Seats = seatIds.Select(id => new Seat { Id = id }).ToList()
            };

            // Save the booking to the database
            // (Assuming we have a repository or data access layer)
            _bookingRepository.Add(booking);

            // Process the payment
            var payment = _paymentService.ProcessPayment(booking.Id, PaymentMethod.CreditCard);

            if (payment.Status == PaymentStatus.Completed)
            {
                booking.Status = BookingStatus.Confirmed;
                _bookingRepository.Update(booking);

                // Send confirmation notification
                _notificationService.SendBookingConfirmation(booking);
            }
            else
            {
                // If payment fails, release the seats
                _seatAllocationService.ReleaseSeats(showId, seatIds);
                throw new InvalidOperationException("Payment failed. Booking could not be completed.");
            }

            transaction.Complete();
            return booking;
        }
    }

    // Implement other IBookingService methods...
}

public class SeatAllocationService : ISeatAllocationService
{
    private readonly IShowRepository _showRepository;

    public SeatAllocationService(IShowRepository showRepository)
    {
        _showRepository = showRepository;
    }

    public bool ReserveSeats(int showId, List<int> seatIds, int userId)
    {
        var show = _showRepository.GetById(showId);
        var seatsToReserve = show.Seats.Where(s => seatIds.Contains(s.Id)).ToList();

        if (seatsToReserve.Any(s => s.IsReserved))
        {
            return false;
        }

        foreach (var seat in seatsToReserve)
        {
            seat.IsReserved = true;
            seat.ReservedBy = userId;
        }

        try
        {
            _showRepository.Update(show);
            return true;
        }
        catch (DbUpdateConcurrencyException)
        {
            // Another user has modified the seats. Retry the operation.
            return ReserveSeats(showId, seatIds, userId);
        }
    }

    // Implement other ISeatAllocationService methods...
}

public class MovieService : IMovieService
{
    private readonly IMovieRepository _movieRepository;
    private readonly ICacheService _cacheService;

    public MovieService(IMovieRepository movieRepository, ICacheService cacheService)
    {
        _movieRepository = movieRepository;
        _cacheService = cacheService;
    }

    public List<Movie> SearchMovies(string title, string language, string genre, DateTime? releaseDate, string cityName)
    {
        var cacheKey = $"MovieSearch:{title}:{language}:{genre}:{releaseDate}:{cityName}";
        var cachedResult = _cacheService.Get<List<Movie>>(cacheKey);

        if (cachedResult != null)
        {
            return cachedResult;
        }

        var movies = _movieRepository.Search(title, language, genre, releaseDate, cityName);
        _cacheService.Set(cacheKey, movies, TimeSpan.FromMinutes(10));

        return movies;
    }

    // Implement other IMovieService methods...
}

public interface IPaymentStrategy
{
    Payment Process(decimal amount);
}

public class CreditCardPaymentStrategy : IPaymentStrategy
{
    public Payment Process(decimal amount)
    {
        // Process credit card payment
    }
}

public class CashPaymentStrategy : IPaymentStrategy
{
    public Payment Process(decimal amount)
    {
        // Process cash payment
    }
}

public class PaymentService : IPaymentService
{
    private readonly ICouponRepository _couponRepository;

    public PaymentService(ICouponRepository couponRepository)
    {
        _couponRepository = couponRepository;
    }

    public Payment ProcessPayment(int bookingId, PaymentMethod method, string couponCode = null)
    {
        var booking = _bookingRepository.GetById(bookingId);
        var amount = CalculateBookingAmount(booking);

        if (!string.IsNullOrEmpty(couponCode))
        {
            var coupon = _couponRepository.GetByCode(couponCode);
            if (coupon != null && coupon.IsValid())
            {
                amount -= coupon.CalculateDiscount(amount);
            }
        }

        IPaymentStrategy paymentStrategy = method == PaymentMethod.CreditCard
            ? new CreditCardPaymentStrategy()
            : new CashPaymentStrategy();

        var payment = paymentStrategy.Process(amount);
        payment.BookingId = bookingId;

        return payment;
    }

    // Implement other IPaymentService methods...
}