BoxOffice
    │
    ├── Application
    │      ├── AppDelegate
    │      └── SceneDelegate
    ├── Model
    │      ├── DailyBoxOffice
    │      ├── MovieDetail
    │      ├── ImageSearch
    │      ├── BoxOfficeService
    │      └── ImageSearchService
    ├── NetWork
    │      ├── EndPointMakeable
    │      ├── MovieDetailEndpoint
    │      ├── DailyBoxOfficeEndpoint
    │      ├── ImageSearchEndPoint
    │      ├── parser
    │      ├── HTTPMethod
    │      └── Provider
    ├── View
    │      ├── Main
    │      ├── BoxOfficeListCell
    │      ├── CalendarView
    │      └── MovieDetailView
    ├── Controller
    │      ├── MovieDetailViewController
    │      ├── CalendarViewController
    │      └── BoxOfficeViewController
    ├── Extension
    │      ├── String+Extension
    │      ├── Int+Extension
    │      └── NSMutableAttributedString + Extesion
    ├── Assests
    ├── LaunchScreen
    └── BoxOfficeTests
          └── BoxOfficeTests

 URLSession.shared.dataTask(with: request) { data, response, error in
            guard let validData = data else { return }
            guard let parsedData = parserType.Parse(data: validData) else {return}
            delegate?.fetchAPIData(data: parsedData)
            guard error != nil else { return }

            guard let httpURLResponse = response as? HTTPURLResponse, (200...299).contains(httpURLResponse.statusCode) else { return }
        }.resume()

URLSession.shared.dataTask(with: request) { data, response, error in
            guard error == nil else { return }
            
            guard let httpURLResponse = response as? HTTPURLResponse, (200...299).contains(httpURLResponse.statusCode) else { return }
            
            guard let validData = data, let parsedData = parser.parse(data: validData) else { return }
            completion(parsedData)
        }.resume()

func loadBoxOfficeAPI<T: Decodable>(urlAddress: String, parser: Parser<T>
                                    ,completion: @escaping (T) -> Void)

extension NSMutableAttributedString {
    func makeRedText(string: String) -> NSMutableAttributedString {
        let attributes: [NSAttributedString.Key: Any] = [.foregroundColor: UIColor.red]
        append(NSAttributedString(string: string, attributes: attributes))
        
        return self
    }
    
    func makeBlueText(string: String) -> NSMutableAttributedString {
        let attributes: [NSAttributedString.Key: Any] = [.foregroundColor: UIColor.blue]
        append(NSAttributedString(string: string, attributes: attributes))
        
        return self
    }
    
    func makeBlackText(string: String) -> NSMutableAttributedString {
        let attributes: [NSAttributedString.Key: Any] = [.foregroundColor: UIColor.black]
        append(NSAttributedString(string: string, attributes: attributes))
        
        return self
    }
}

extension NSMutableAttributedString {
    func makeColorToText(string: String, color: UIColor) -> NSMutableAttributedString {
        let attributes: [NSAttributedString.Key: Any] = [.foregroundColor: color]
        append(NSAttributedString(string: string, attributes: attributes))
        
        return self
    }
}

setUpCompositionalLayout() -> UICollectionViewLayout {
    let layout = UICollectionViewCompositionalLayout {
        // item - group - section 
    }
    return layout
}

class EndPoint {
        var baseURL: BaseURL
        var path: Path
        var method: HTTPMethod
        var queryItems: [URLQueryItem]
        
    init(baseURL: BaseURL, path: Path, method: HTTPMethod, queryItems: [URLQueryItem]) {
        self.baseURL = baseURL
        self.path = path
        self.method = method
        self.queryItems = queryItems
    }
    ...

let endpoint = EndPoint(baseURL: BaseURL.kobis,
                                path: Path.dailyBoxOffice,
                                method: HTTPMethod.get,
                                queryItems: [URLQueryItem(name: QueryItemsName.key.rawValue,
                                                          value: QueryItemsValue.keyValue.rawValue),
                                             URLQueryItem(name: QueryItemsName.targetDate.rawValue,
                                                          value: QueryItemsValue.targetDateValue.rawValue)])

protocol EndpointMakeable {
    var baseURL: String { get }
    var path: String { get }
    var method: String { get }
    var queryItems: [URLQueryItem] { get }
    
    func makeURL() -> URL?
    func makeURLRequest() -> URLRequest?
}

extension EndpointMakeable {
    
    func makeURL() -> URL? {
        var urlComponents = URLComponents(string: baseURL)
        urlComponents?.path = path
        urlComponents?.queryItems = queryItems
        
        guard let url = urlComponents?.url else { return nil }
        
        return url
    }
    
    func makeURLRequest() -> URLRequest? {
        guard let url = makeURL() else { return nil }
        var urlRequest = URLRequest(url: url)
        urlRequest.httpMethod = method
        
        return urlRequest
    }
}

struct MovieDetailEndpoint: EndpointMakeable {
    var baseURL: String = "https://kobis.or.kr"
    var path: String = "/kobisopenapi/webservice/rest/movie/searchMovieInfo.json"
    var method: String = HTTPMethod.get.rawValue
    var queryItems: [URLQueryItem] = [URLQueryItem(name: "key", value: "f5eef3421c602c6cb7ea224104795888")]

final class BoxOfficeViewController: UIViewController {
    @IBOutlet weak var boxOfficeListCollectionView: UICollectionView!
    lazy var activityIndicator = UIActivityIndicatorView()

    private var dailyBoxOffice: DailyBoxOffice?
    private var provider = Provider()

    override func viewDidLoad() {
        super.viewDidLoad()
        fetchDailyBoxOfficeAPI()
        setUpView()
    }

    private func fetchDailyBoxOfficeAPI() {
        var dailyBoxOfficeEndpoint = DailyBoxOfficeEndpoint()
        dailyBoxOfficeEndpoint.insertDateQueryValue(date: "20230327")

        provider.loadBoxOfficeAPI(endpoint: dailyBoxOfficeEndpoint,
                                  parser: Parser<DailyBoxOffice>()) { parsedData in
            self.dailyBoxOffice = parsedData

            DispatchQueue.main.async {
                self.boxOfficeListCollectionView.reloadData()
                self.activityIndicator.stopAnimating()
            }
        }
    }
}

// Service
class BoxOfficeService {
    let provider = Provider()
    var dailyBoxOffice: DailyBoxOffice?
    var movieDetail: MovieDetail?
    var movieCode = ""
    
    func fetchDailyBoxOfficeAPI(date: String,completion: @escaping () -> Void) {
        var dailyBoxOfficeEndpoint = DailyBoxOfficeEndpoint()
        dailyBoxOfficeEndpoint.insertDateQueryValue(date: date)
        
        provider.loadBoxOfficeAPI(endpoint: dailyBoxOfficeEndpoint,
                                  parser: Parser<DailyBoxOffice>()) { parsedData in
            self.dailyBoxOffice = parsedData
            completion()
        }
    }
    ...
}
    
// ViewController
final class BoxOfficeViewController: UIViewController {
    @IBOutlet weak var boxOfficeListCollectionView: UICollectionView!
    lazy var activityIndicator = UIActivityIndicatorView()
    let boxOfficeService = BoxOfficeService()
    private var provider = Provider()

    override func viewDidLoad() {
        super.viewDidLoad()
        fetchDailyBoxOffice()
        setUpView()
    }

    private func fetchDailyBoxOffice() {
        boxOfficeService.fetchDailyBoxOfficeAPI() {
            DispatchQueue.main.async {
                self.boxOfficeListCollectionView.reloadData()
                self.activityIndicator.stopAnimating()

//viewDidLoad
 func removeCacheAfter30min() {
        DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 1800) {
            URLCache.shared.removeAllCachedResponses()
            print("캐시 지워짐")
    }
}

  private func setUpCompositionalLayout() -> UICollectionViewLayout {
        let layout = UICollectionViewCompositionalLayout {
            (sectionIndex: Int, layoutEnvironment: NSCollectionLayoutEnvironment) -> NSCollectionLayoutSection? in
            
            let itemSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(1.0), heightDimension: .fractionalHeight(1.0))
            let item = NSCollectionLayoutItem(layoutSize: itemSize)
            
            item.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 0, bottom: 0, trailing: 0)
            
            let groupHeight =  NSCollectionLayoutDimension.fractionalWidth(1/4)
            let groupSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(1.0), heightDimension: groupHeight)
            let group = NSCollectionLayoutGroup.horizontal(layoutSize: groupSize, subitem: item, count: 1)
            let section = NSCollectionLayoutSection(group: group)
            
            return section
        }
        return layout
    }

private func setUpCompositionalListLayout() -> UICollectionViewLayout {
        let configuration = UICollectionLayoutListConfiguration(appearance: .plain)
        let layout = UICollectionViewCompositionalLayout.list(using: configuration)
        
        return layout
    }

self.availableDateRange = DateInterval(start: Date(timeIntervalSinceReferenceDate: 0), end: Date(timeIntervalSinceNow: -86400))