import RxSwift

protocol ViewModelType {

    associatedtype Input

    associatedtype Output

    func transform(_ input: Input) -> Output
}

protocol RxViewModelType: ViewModelType {

    var disposeBag: DisposeBag { get set }
}

struct NetworkManager {
    // 서버로부터 데이터 받을시 + 보낼시 통합
    typealias FetchType<T:Decodable> = Single<Result<T, NetworkError>>
    // 받아올 모델은 없을시
    typealias NoneModelFetchType = Single<Result<Void,NetworkError>>
}

protocol ErrorCase {
    func errorCase(_ errorCode: Int,_ description: String) -> NetworkError
}

enum NetworkRouter {
    case authentication(authenticationRouter)
    case poster(PostsRouter)
    case comments(CommentRouter)
    case like(LikeRouter)
    case follow(FollowRouter)
    case profile(ProfileRouter)
    case payments(PaymentsRouter)
}
// 각각의 라우터들은 해당 프로토코콜을 채택 해야 합니다.
protocol TargetType: URLRequestConvertible {

    var method: HTTPMethod { get }

    var path: String { get }

    var parametters: Parameters? { get }

    var headers: [String: String] { get }

    var queryItems: [URLQueryItem]? { get }

    var version: String { get }

    var body: Data? { get }

    var multipart: MultipartFormData { get }

    func errorCase(_ errorCode: Int, _ description: String) -> NetworkError
}

final class ChatSocketManager {

    typealias ChatSocketManagerResult = PublishSubject<Result<ChatModel,ChatSocketManagerError>>

    static let shared = ChatSocketManager()

    private var manager: SocketManager?

    private var socket: SocketIOClient?

    private let decodable = JSONDecoder()

    /// 해당 프로퍼티를 통해 채팅 정보를 받습니다.
    let chatSocketResult = ChatSocketManagerResult ()

    private init() {
        setupManager()
    }
}

// 클라이언트
extension ChatSocketManager {

    func setID(id: String) {
        removeSocket()
        let roomId = SocketCase.Chat.rawValue + id
        socket = manager?.socket(forNamespace: roomId)
        guard let socket else {
            chatSocketResult.onNext(.failure(.nilSocat))
            return
        }
        startObserver(socket: socket)
    }

    func startSocket()
    func stopSocket()
    func removeSocket()
}

// SceneDelegate
func sceneWillEnterForeground(_ scene: UIScene) {
    ChatSocketManager.shared.startSocket()
}

func sceneDidEnterBackground(_ scene: UIScene) {
    ChatSocketManager.shared.stopSocket()
}

final class NetWorkServiceMonitor {

    enum ConnectionType {
        case cellular
        case ethernet
        case unknown
        case wifi
    }

    static let shared = NetWorkServiceMonitor()

    fileprivate let queue = DispatchQueue.global(qos: .background)

    fileprivate let monitor: NWPathMonitor

    fileprivate(set) var isConnected: Bool = false

    fileprivate(set) var connectionType: ConnectionType = .unknown

    let behaivorNetwork = PublishRelay<Bool> ()

    let behaiborNetworkType = PublishRelay<ConnectionType> ()
}

extention NetWorkServiceMonitor {

    func startMonitor()

    private func getConnectionType(_ path: NWPath)

    private func stopMonitoring()

}

func downloadImage(imageUrl: String?, resizing: CGSize, complite: @escaping (Result<Data?,NetworkError>)-> Void ) {

        let processor = DownsamplingImageProcessor(size: resizing)
        var scale: CGFloat = 0

        if let screenCurrent = UIScreen.current?.scale {

            scale = screenCurrent
        } else {
            scale = UIScreen.main.scale
        }

        guard let imageUrl else {
            complite(.failure(.failMakeURLRequest))
            return
        }

        KingfisherManager.shared.retrieveImage(with: URL(string: imageUrl)!, options: [
            .processor(processor),
            .transition(.fade(1)),
            .requestModifier(KingFisherNet()),
            .scaleFactor(scale),
            .cacheOriginalImage
        ]) { imageResult in
            switch imageResult {
            case .success(let result):
                complite(.success(result.data()))
            case .failure(_):
                complite(.failure(.failMakeURLRequest))
                break
            }
        }
    }

// 레이아웃을 구성하는데에 필요한 데이터를 계산하는 클래스 입니다.
final class LayoutBuilder {

    /// 각 열의 너비를 계산하는 계산 속성
    var columnWidth: CGFloat { get set }

    /// 특정 아이템의 프레임을 계산
    func frame(for row: Int) -> CGRect

    /// 행 레이아웃 아이템 생성
    func makeLayoutItem(for row: Int)

    /// 가장 낮은 열의 인덱스를 반환
    func columnIndex() -> Int

    // item x,y 좌표가 어딘지 계산해
    func itemOrigin(width: CGFloat) -> CGPoint

    // 모든 열중 가장 높은 높이를 반환
    func maxcolumHeight() -> CGFloat
}

/// 핀터레스트 레이아웃 구성에 필요한 세부사항들을 정의하는 구조체입니다.
struct PinterestConfiguration {
    let numberOfColumns: Int
    let interItemSpacing: CGFloat /
    let edgeInset: NSDirectionalEdgeInsets
    let itemHeightProvider: (_ index: Int,_ itemWidth: CGFloat) -> CGFloat // 특정 인뎃스 아이템 높이 클로저
    let itemCountProfider: () -> Int
}

final class PinterestcompositionalLayout {

    static func makeLayoutSection(
        config: PinterestConfiguration,
        environment: NSCollectionLayoutEnvironment,
        sectionIndex: Int
    ) -> NSCollectionLayoutSection

}

func commentValid(_ string: String, maxCount: Int) -> Bool {
    guard !string.isEmpty else {
        return false
    }
    let pattern = "^[^\n]{1,\(maxCount)}$"
    if string.contains("\n") {
        return false
    } else {
        return matchesPatternBool(string, pattern: pattern)
    }
}

 override func configureLayout() {

    emptyView.snp.makeConstraints { make in
        make.top.horizontalEdges.equalToSuperview()
        make.bottom.equalTo(safeAreaLayoutGuide.snptop)
    }

    tableView.snp.makeConstraints { make in
        make.horizontalEdges.bottom.equalTo(safeAreaLayoutGuide)
            make.top.equalToSuperview()
    }

    tableView.rowHeight = UITableView.automaticDimension

    tableView.estimatedRowHeight = 240

}

/// ViewController
   override func viewDidLoad() {
        super.viewDidLoad()
        homeView.tableView.tableHeaderView = homeView.headerView
        navigationController?.hidesBarsOnSwipe = true
    }

struct PaymentsModel: Codable {

    let impUID: String
    let postID: String
    let productName: String
    var price: Int

    enum CodingKeys: String, CodingKey {
        case impUID = "imp_uid"
        case postID = "post_id"
        case productName
        case price
    }
    ... 생략 ...
}
'''
encoder.keyEncodingStrategy = .convertToSnakeCase