import Alamofire
import Foundation

/// 에러 정의
enum NetworkError: Error {
    case notValidateStatusCode  // 유효하지 않는 StatusCode
    case noData                 // 결과 데이터 미존재
    case failDecode             // Decode 실패
}

/// 통신 Enum
enum API {
    /// 유저 정보가져오기
    case getUserInfo(name: String)
    /// 챔피언 리스트 가져오기
    case getChampionList
}

// MARK: 통신 필요 정보 관련
extension API {
    /// API Key
    private var key: String {"발급 받은 API 키"}
    
    /// 도메인
    private var domain: String {
        switch self {
        case .getUserInfo:
            return "https://kr.api.riotgames.com"
        case .getChampionList:
            return "http://ddragon.leagueoflegends.com"
        }
    }
    
    /// URL Path
    private var path: String {
        switch self {
        case .getUserInfo(name: let name):
            return "/lol/summoner/v4/summoners/by-name/\(name)"
        case .getChampionList:
            return "/cdn/11.16.1/data/en_US/champion.json"
        }
    }
    
    /// HTTP 메소드
    private var method: Alamofire.HTTPMethod {
        switch self {
        case .getUserInfo, .getChampionList:
            return .get
        }
    }
    
    /// API Key 필요 여부
    private var isNeedAPIKey: Bool {
        switch self {
        case .getUserInfo:
            return true
        default:
            return false
        }
    }
    
    /// 통신 헤더
    private var header: HTTPHeaders {
        
        var result = HTTPHeaders([
            HTTPHeader(name:"Accept-Language", value: "ko-KR,ko;q=0.9"),
            HTTPHeader(name:"Accept-Charset", value: "application/x-www-form-urlencoded; charset=UTF-8"),
            HTTPHeader(name:"Origin", value: "https://developer.riotgames.com")
        ])
        
        if isNeedAPIKey {
            result.add(HTTPHeader(name: "X-Riot-Token", value: key))
        }
        return result
    }
    
    /// Body Parameter - 주로 Get으로 예상되어 필요 x
    private var parameter: [String:Any]? {
        switch self {
        case .getUserInfo: return nil
        case .getChampionList: return nil
        }
    }
}

/// 통신 요청
/// - Parameter complete: 결과 클로저 - 성공시 NSDictionary, 실패시 정의 해둔 에러
func request(complete: @escaping ((Result<NSDictionary?,NetworkError>)->())) {
    var url = domain
    
    if let convertedPath = path.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) {
        url += convertedPath
    }
    AF.request(url, method: method, parameters: parameter, headers: header)
        .responseJSON { response in
            
            // 통신 결과 처리
            switch response.result {
            case .success(let dict):
                // 성공
                complete(.success(dict as? NSDictionary))
            case .failure:
                
                // 결과는 없지만 statusCode에 따라 확인이 필요할 수 있음.
                if let stCode = response.response?.statusCode, 200..<300 ~= stCode {
                    // 성공
                    complete(.success(nil))
                } else {
                    // 진짜 실패
                    complete(.failure(.notValidateStatusCode))
                }
            }
        }
}

/// 통신 요청 (with Generic)
/// - Parameters:
///     - dataType: Generic으로 선언된 자료형의 타입을 받는다.
///     - complete: 클로저 - 성공시 T의 객체, 실패시 선언해둔 에러
func request<T: Decodable>(dataType: T.Type, complete: @escaping ((Result<T,NetworkError>)->())) {
    
    // 1. 위에 선언한 요청 메소드를 통해 NSDictionary를 받는다.
    request { result in
        switch result {
        case .success(let dict):
            
            // 2. 데이터 존재 확인
            guard let dicData = dict else {
                // 데이터 미존재 에러
                complete(.failure(.noData))
                return
            }
            
            // 3. 얻은 NSDictionary를 JSON 데이터로 바꾼뒤 T형태로 Decode 해준다.
            guard
                let json = try? JSONSerialization.data(withJSONObject: dicData, options: .prettyPrinted),
                let data = try? JSONDecoder().decode(T.self, from: json)
            else {
                // 4. Decode실패
                complete(.failure(.failDecode))
                return
            }
            
            // 5. T 객체 생성 성공!
            complete(.success(data))
            
        case .failure(let e):
            // 6. Request 실패
            complete(.failure(e))
        }
    }
}

// 정의
let api = API.getChampionList

// 요청
api.request { result in
    switch result {
    case .success(let dict):
        print(dict)
        
    case .failure(let e):
        print(e)
    }
}

struct SummonerDTO: Codable {
    let id, accountId, puuid, name: String
    let profileIconId, revisionDate, summonerLevel: Int
}

// 사용
let api = API.getUserInfo(name: name)

api.request(dataType: SummonerDTO.self) { result in
    switch result {
    case .success(let data):
        printSummonerInfo(data)
    case .failure(let e):
        print(e)
    }
}

// ...
// 출력
func printSummonerInfo(_ summoner: SummonerDTO) {
    print("""
        ** 결과 **
        id: \(data.id)
        accountId: \(data.accountId)
        puuid: \(data.puuid)
        name: \(data.name)
        profileIconId: \(data.profileIconId)
        revisionDate: \(data.revisionDate)
        summonerLevel: \(data.summonerLevel)
        """)
}