//
//  Router.swift
//  XuXuCheck
//
//  Created by henseycai on 2025/6/18.
//

import Foundation
import Alamofire
import ObjectMapper

internal extension APIService{
    
    enum Router: URLRequestConvertible {
        case interface_login(String,String,String)
        case interface_register(String,String,String,String)
        case interface_forgetpwd(String,String,String,String)
        case interface_verified_code(String,String,String)
        case interface_family_getself
        case interface_result_addrecord([Int],[[[Double]]])
        case interface_result_pic
        case interface_result_longtest
                

        var baseUrl: URL {
            return URL(string: API.baseUrl.appending(API.apiVersion))!
        }
        
        var method: HTTPMethod {
            switch self {
            case .interface_login: return .post
            case .interface_register: return .post
            case .interface_forgetpwd: return .post
            case .interface_verified_code: return .post
            case .interface_family_getself: return .post
            case .interface_result_addrecord: return .post
            case .interface_result_pic: return .post
            case .interface_result_longtest: return .post
                
                
            }
        }
        
        var path: String {
            switch self {
            case .interface_login(_, _, _): return API.interface_login
            case .interface_register(_, _, _, _): return API.interface_register
            case .interface_forgetpwd(_, _, _, _): return API.interface_forgetpwd
            case .interface_verified_code(_, _, _): return API.interface_verified_code
            case .interface_family_getself: return API.interface_family_getself
            case .interface_result_addrecord(_, _): return API.interface_result_addrecord
            case .interface_result_pic: return API.interface_result_pic
            case .interface_result_longtest: return API.interface_result_longtest
                
            }
        }

        var params: [String: Any]?  {
            switch self {
            case .interface_login(let username,let code, let password):
                return ["username":username,"code":code,"password":password,"app_version":"4.2.0.2025.0607","system":"iOS","system_version":brandName,"device_model":systemModel,"device_brand":brandName]
            case .interface_register(let username,let code,let password,let confirm_password):
                return ["username":username,"code":code,"password":password,"confirm_password":confirm_password,"system":"iOS","system_version":brandName,"device_model":systemModel,"device_brand":brandName]
            case .interface_forgetpwd(let username,let code,let password,let confirm_password):
                return ["username":username,"code":code,"password":password,"confirm_password":confirm_password,"system":"iOS","system_version":brandName,"device_model":systemModel,"device_brand":brandName]
            case .interface_verified_code(let mobile,let check,let forW):
                return ["keyword":mobile,"check":check,"for":forW]
            case .interface_family_getself: return ["usertoken":Storage.shared.usertoken]
            case .interface_result_addrecord(_, _): return nil
            case .interface_result_pic: return nil
            case .interface_result_longtest: return nil
                
                
            }
        }
        
        
        func asURLRequest() throws -> URLRequest {
            
            let url = baseUrl.appendingPathComponent(path)
            var request = URLRequest(url: url)
            request.httpMethod = method.rawValue
                        
            //request.addValue(Storage.shared.$setCookie.wrappedValue, forHTTPHeaderField: "Cookie") //添加cookie
            //request.httpBody = try JSONSerialization.data(withJSONObject: params,options: [])
            if(Storage.shared.isLogin){
//                request.addValue("Authorization", forHTTPHeaderField: "Bearer ".appending(Storage.shared.usertoken))
                request.setValue("Bearer ".appending(Storage.shared.usertoken), forHTTPHeaderField: "Authorization")
            }

            
            request.setValue("1", forHTTPHeaderField: "X-Platform")
            request.setValue(channel, forHTTPHeaderField: "X-Channel")
            
            let date = Date()
            let time = Int(date.timeIntervalSince1970)
            let sign = getSign(time: time)

            request.setValue(String(time), forHTTPHeaderField: "X-Time")
            request.setValue(sign, forHTTPHeaderField: "X-Sign")
            request.setValue(TimeZone.autoupdatingCurrent.identifier, forHTTPHeaderField: "X-TimeZone")
            request.setValue(Locale.current.identifier, forHTTPHeaderField: "X-Locale")
            

            
            switch self {
            case .interface_login(_, _, _),
                    .interface_register,
                    .interface_forgetpwd,
                    .interface_verified_code,
                    .interface_family_getself,
                    .interface_result_pic,
                    .interface_result_longtest:
                
                    //let encoding = JSONEncoding.default
                    let encoding = URLEncoding.default
                    
                    print(request.allHTTPHeaderFields ?? "")
                    print(params ?? "")
                    
                    return try encoding.encode(request, with: params)

            case .interface_result_addrecord(let desc, let resData):
                var recordModel = RecordModel(usertoken: Storage.shared.usertoken, memberID: Storage.shared.member_id,
                                              sign: sign, time: time, userid: Storage.shared.userid, color: desc[0], items: desc[1], locator: desc[2], recordType: 0, channel: channel, data: [])
                
//                var recordModel = RecordModel(usertoken: Storage.shared.usertoken, memberID: Storage.shared.member_id,
//                                              sign: sign, time: time, userid: Storage.shared.userid, color: 1, items: 14, locator: 2, recordType: 0, channel: channel, data: [])
                for i in 0..<resData.count {
                    var data2D = [Datum]()
                    
                    for j in 0..<resData[i].count {
                        //let dataItem = Datam()
                        var v = ""
                        for k in 0..<resData[i][j].count {
                            v.append(String(format: "%.1f",resData[i][j][k]))

                            if( (k + 1) < resData[i][j].count){
                                v.append(",")
                            }
                        }
                        data2D.append(Datum(i: j, v:v))
                    }
                    recordModel.data.append(data2D)
                }

                var jsonParameters: Parameters!
                jsonParameters = try encodeJson(recordModel)
                let encoding = JSONEncoding.default

                
                return try encoding.encode(request, withJSONObject: jsonParameters)
                
            }
        }
        
        func encodeJson<Body: Encodable>(_ body: Body) throws -> Parameters {
            var parameters: Parameters!
            let encoder = JSONEncoder()
            encoder.keyEncodingStrategy = .convertToSnakeCase

            do {
                let data = try encoder.encode(body)
                parameters = try JSONSerialization.jsonObject(with: data) as? Parameters ?? Parameters()
            } catch {
                throw error
            }

            return parameters
        }
    }
}