struct DailyBoxOfficeURL: URLAcceptable {
    let url: URL?
    var urlComponents: URLComponents?
    let key: URLQueryItem
    let targetDate: URLQueryItem
    ...
}

struct MovieInfomationURL: URLAcceptable {
    let url: URL?
    var urlComponents: URLComponents?
    let key: URLQueryItem
    let movieCode: URLQueryItem
    ...
}

// url프로퍼티를 갖는 프로토콜 구현
protocol NetworkRequestable {
    var urlRequest: URLRequest? { get }
    var url: URL? { get }
}
// EndPoint 타입 구현
struct EndPoint: NetworkRequestable {
    var urlRequest: URLRequest?
    var url: URL?
        
    mutating func setURLRequest(method: HttpMethod, body: Data?) {
       //// urlRequest 구현부
    ...
}
// 박스오피스, 상세정보 별 protocol, extension 구현
protocol DailyBoxOfficeProtocol {
    mutating func setURLParameter() //매개변수 생략
}

extension EndPoint: DailyBoxOfficeProtocol {
    mutating func setEndPoint() {  //매개변수 생략
        setURLParameter(baseURL: baseURL, key: key, targetDate: targetDate, itemPerPage: itemPerPage, multiMovieType: multiMovieType, nationCode: nationCode, wideAreaCode: wideAreaCode)
        setURLRequest(method: method, body: body)
    }
    
    mutating func setURLParameter(baseURL: String, key: String, targetDate: String, itemPerPage: String? = nil, multiMovieType: MovieType? = nil, nationCode: NationalCode? = nil, wideAreaCode: String? = nil) {
    ...
}      

enum BoxOfficeEndPoint {
    case DailyBoxOffice(tagetDate: String)
    case MovieInformation(movieCode: String)
    case MoviePosterImage(query: String)
}
    ...
}

struct DailyBoxOffice: Decodable {
   ...
    struct BoxOfficeResult: Decodable {
        ...
        let boxOfficeList: [Movie]
        ...        
        struct Movie: Decodable, Hashable {
            // Movie의 모든 프로퍼티
    ...
}

final class DailyBoxOfficeViewController: UIViewController {
    private typealias DataSource = UICollectionViewDiffableDataSource<Section, DailyBoxOffice.BoxOfficeResult.Movie>
    ...
}

struct MovieItem: Hashable {
    init(from movie: DailyBoxOffice.BoxOfficeResult.Movie) {
        self.rank = movie.rank
        self.rankVariance = movie.rankVariance
        self.rankOldAndNew = movie.rankOldAndNew
        self.code = movie.code
        self.name = movie.name
        self.audienceCount = movie.audienceCount
        self.audienceAccumulation = movie.audienceAccumulation
    }

    let identifier = UUID() // uniqueIdentifier를 주기 위해 구현
    let rank: String
    let rankVariance: String
    let rankOldAndNew: String
    let code: String
    let name: String
    let audienceCount: String
    let audienceAccumulation: String
}

final class DailyBoxOfficeViewController: UIViewController {
    private typealias DataSource = UICollectionViewDiffableDataSource<Section, MovieItem>
    ...
    private func fetchDailyBoxOfficeData() {
        guard let endPoint = boxOfficeEndPoint else { return }
        
    networkManager.request(endPoint: endPoint, returnType: DailyBoxOffice.self) { [weak self] in
        switch $0 {
        case .failure(let error):
            print(error)
        case .success(let result):
            // movieItems 타입의 프로퍼티안에 전달받은 값 중 필요한 값들만 골라 넣어줌
            for index in 0..<result.boxOfficeResult.boxOfficeList.count {
                self?.movieItems.append(MovieItem.init(from: result.boxOfficeResult.boxOfficeList[index]))
            }
        ...
}

enum BoxOfficeEndPoint {
    ...
    // 영화 포스터 이미지를 받아오기 위한 API
    case MoviePosterImage(query: String, httpMethod: HttpMethod)
    ...
}

func load(url: URL, completion: @escaping () -> Void) {
    DispatchQueue.global().async { [weak self] in
        guard let data = try? Data(contentsOf: url),
              let image = UIImage(data: data) else { return }
    ...
}

func load(url: URL, completion: @escaping ((Result<UIImage, NetworkError>) -> Void)) {
    let urlRequest = URLRequest(url: url)
        
    let task = URLSession.shared.dataTask { ... }
    ...
}

func createMovieListLayout() -> UICollectionViewLayout {
    let itemSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(1.0),
                                          heightDimension: .fractionalHeight(0.1))
    let item = NSCollectionLayoutItem(layoutSize: itemSize)
    item.contentInsets = NSDirectionalEdgeInsets(top: 0, leading: 0, bottom: 0, trailing: 0)
}

private func createMovieListLayout() -> UICollectionViewLayout {
        let itemSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(1.0),
                                              heightDimension: .estimated(44))
    ...
    let groupSize = NSCollectionLayoutSize(widthDimension: .fractionalWidth(1.0),
                                               heightDimension: .estimated(44))
    
    ...
    collectionView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
    ...
    separatorView.autoresizingMask = .flexibleWidth
    ...
}

// View에서 Label에 입력될 String을 받는 메서드
func setupLabels(name: String, audienceInformation: String, rank: String, rankMark: String, audienceVariance: String, rankMarkColor: MovieRankMarkColor) {
        nameLabel.text = name
        audienceInformationLabel.text = audienceInformation
        rankLabel.text = rank
        rankMarkLabel.text = rankMark
        rankMarkLabel.textColor = rankMarkColor.color
        audienceVarianceLabel.text = audienceVariance
    }

// ViewController에서 넘겨주는 코드
private func setupDataSource() {
        movieDataSource = DataSource(collectionView: collectionView) { [weak self] collectionView, indexPath, itemIdentifier in
        ...
                
        guard let movieInformation = self?.setupCellLabels(with: itemIdentifier) else { return UICollectionViewCell() }
        cell.setupLabels(...)
        ...
    }

enum MovieRankMarkColor {
    case blue
    case red
    case black
    
    var color: UIColor {
        switch self {
        case .blue:
            return UIColor.systemBlue
        case .red:
            return UIColor.systemRed
        case .black:
            return UIColor.black
        }
    }
}

//View에서 Label에 입력될 String을 받는 메서드
func setupDescriptionLabels(...) {
        directorDescriptionLabel.text = director
        productionYearDescriptionLabel.text = productionYear
        ....
}

// ViewController에서 넘겨주는 코드
 private func fetchMovieInformation() {
        networkManager.request(endPoint: boxOfficeEndPoint, returnType: MovieInformation.self) { [weak self] in
            ...
            DispatchQueue.main.async {
                self?.movieInformationScrollView.setupDescriptionLabels(director: movieInformationItem.directors, productionYear: movieInformationItem.productionYear, openDate: movieInformationItem.openDate, showTime: movieInformationItem.showTime, watchGrade: movieInformationItem.audits, nation: movieInformationItem.nations, genre: movieInformationItem.genres, actor: movieInformationItem.actors)
                }
    ...
}

protocol LabelSetter {
    func configureLabels( ... )
}

final class DailyBoxOfficeListCollectionViewCell: LabelSetter, ... { ... }
final class DailyBoxOfficeIconCollectionViewCell: LabelSetter, ... { ... }
    
final class DailyBoxOfficeViewController {
    private func setupDataSource() {
        ...
        //dequeue 할 때 LabelSetter 프로토콜 타입으로 변환
        guard let cell = collectionView.dequeueReusableCell(
            withReuseIdentifier: cellIdentifier,
            for: indexPath) as? LabelSetter else { return UICollectionViewCell() }
            
            self?.setupLabels(with: itemIdentifier) { movieListLabel, audienceInformationLabel, movieRankLabel, audienceVarianceLabel in
                cell.configureLabels(movieRankLabel, audienceVarianceLabel, movieListLabel, and: audienceInformationLabel)
            }
         
            return cell as? UICollectionViewCell
        ...
}

final class DailyBoxOfficeViewController {
    private func setupDataSource() {
        ...
        switch self?.screenMode {
        case .list:
            guard let cell = collectionView.dequeueReusableCell(
                withReuseIdentifier: DailyBoxOfficeListCollectionViewCell.reuseIdentifier,
                for: indexPath) as? DailyBoxOfficeListCollectionViewCell else { return UICollectionViewCell() }
            ...
                
            cell.setupLabels( ... )
                
            return cell
        case .icon:
            guard let cell = collectionView.dequeueReusableCell(
                withReuseIdentifier: DailyBoxOfficeIconCollectionViewCell.reuseIdentifier,
                for: indexPath) as? DailyBoxOfficeIconCollectionViewCell else { return UICollectionViewCell() }
            ...
                
            cell.setupLabels( ... )
                
            return cell
        ...
}    

final class TypeChanger {
    
    func changeToEntity(_ movie: MovieInformation.MovieInformationResult.Movie) -> MovieDetails {
        let details = MovieDetails()
    ...
    }
    ...
    func changeToEntity(_ movies: [DailyBoxOffice.BoxOfficeResult.Movie]) -> Movies {
    ...
    }
}

final class CoreDataManager<Entity: NSManagedObject & EntityKeyProtocol , Element>: DataManager {
    private let context = (UIApplication.shared.delegate as? AppDelegate)?.persistentContainer.newBackgroundContext()
    
    func create(key: String, value: [Element]) {
        guard let context = self.context,
              let entity = NSEntityDescription.entity(forEntityName: Entity.key, in: context),
              let storage = NSManagedObject(entity: entity, insertInto: context) as? Entity else { return }
        
        setValue(at: storage, key: key , data: value)
        save()
    }
    
    func read(key: String) -> Entity? {
        guard let context = self.context else { return nil }
        
        let filter = filteredDataRequest(entityType: Entity.self, key: key)
        
        do {
            let data = try context.fetch(filter)
            return data.first
        } catch {
            return nil
        }
    }  
    ...
    
    private func setValue(at target: Entity, key: String, data: [Element]) {
        guard let data = data.first else { return }
        let contents = data
        
        if target is DailyBoxOfficeData {
            target.setValue(Date.now, forKey: "createdAt")
            target.setValue(key, forKey: "selectedDate")
            target.setValue(contents, forKey: "movies")
        } else if target is MovieInformationData {
            target.setValue(Date.now, forKey: "createdAt")
            target.setValue(key, forKey: "movieCode")
            target.setValue(contents, forKey: "movieDetails")
        }
    }
    ...
    
    private func filteredDataRequest<T: NSManagedObject>(entityType: T.Type, key: String) -> NSFetchRequest<T> {
        let fetchRequest = NSFetchRequest<T>(entityName: String(describing: entityType))
        
        if entityType == DailyBoxOfficeData.self {
            fetchRequest.predicate = NSPredicate(format: "selectedDate == %@", key)
        } else if entityType == MovieInformationData.self {
            fetchRequest.predicate = NSPredicate(format: "movieCode == %@", key)
        }
        
        return fetchRequest
    }
}

protocol DataManager {
    
    associatedtype Element
    associatedtype Entity
    
    func create(key: String, value: [Element])
    
    func read(key: String) -> Entity?
    
    func update(key: String, value: [Element])
    
    func delete()
}

final class DailyBoxOfficeListCollectionViewCell: UICollectionViewCell {
    static let reuseIdentifier = "DailyBoxOfficeListCollectionViewCell"
    ...
}

final class DailyBoxOfficeListCollectionViewCell: UICollectionViewCell {
    static let reuseIdentifier = String(describing: DailyBoxOfficeListCollectionViewCell.self)
    ...
}