lol

calcWinningPair

func calcWinningPair(odds: [[String: Any]]) -> [[String: Any]] {
        var handicapMap: [Float: Any] = [:]
        var absSpecialValues: [Float] = []
        
        odds.forEach {
            let specialValue = $0["specialValue"] as! String
            if let floatSpecialValue = Float(specialValue) {
                let absSpecValue = abs(floatSpecialValue)
                
                absSpecialValues.append(absSpecValue)
                absSpecialValues = absSpecialValues.removeDuplicates()
                
            }
        }
        print("absSpecialValues: \(absSpecialValues)")
        
        
        // 1). составить мапу
        for specialValue in absSpecialValues {
            var sortedBySpecialValueArray: [[String: Any]] = []
            
            odds.forEach {
                if let floatSpecialValue = Float($0["specialValue"] as! String) {
                    let absSpecValue = abs(floatSpecialValue)
                    if absSpecValue == specialValue {
                        sortedBySpecialValueArray.append($0)
                    }
                }
            }
            
            handicapMap[specialValue] = sortedBySpecialValueArray
        }
        
        for sv in absSpecialValues {
            print("=====================")
            print("\(sv): \(handicapMap[sv]!)")
            print("=====================")
        }
        
        // 2). перебрать мапу так, что остануться только пары
        // - заглянуть в каждый value
        // - выбрать там пару
        // - записать в handicapMap
        
        for specialValue in absSpecialValues {
            let odds = handicapMap[specialValue]! as! [[String: Any]]
            // из odds -> составить мапу по одинаковым specialValue - получим пары
            var svMap: [Float: Any] = [:]
            var svArray: [Float] = []
            
            // собираем массив всех specialValue
            odds.forEach {
                let specialValue = $0["specialValue"] as! String
                if let floatSpecialValue = Float(specialValue) {
                    svArray.append(floatSpecialValue)
                }
            }
            svArray = svArray.removeDuplicates()
            print(svArray)
            
            // составляем мапу [sv : odds]
            for sv in svArray {
                var pair: [[String: Any]] = []
                
                odds.forEach {
                    let specialValue = $0["specialValue"] as! String
                    if let floatSpecialValue = Float(specialValue) {
                        if sv == floatSpecialValue {
                            pair.append($0)
                        }
                    }
                }
                
                let pairSortedByOutcome = pair.sorted {
                    Float($0["outCome"] as! String)! < Float($1["outCome"] as! String)!
                }
                
                svMap[sv] = pairSortedByOutcome
            }
            
            for sv in svArray {
                print("=====================")
                print("\(sv): \(svMap[sv]!)")
                print("=====================")
            }
            
            // сначала сортируем по diff
            var diffMap: [Float: Any] = [:]
            for sv in svArray {
                if let pair = svMap[sv] as? [[String: Any]] {
                    
                    var coeffDiff: Float = 0.0
                    var coeffArray: [Float] = []
                    
                    for odd in pair {
                        if let coeff = odd["coefficient"] as? String {
                            if let floatCoeff = Float(coeff) {
                                coeffArray.append(floatCoeff)
                            }
                        } else {
                            // добавляем коэффициент 0.0, если с бэкенда пришел <null>
                            coeffArray.append(0.0)
                        }
                    }
                    
                    if coeffArray.count > 1 {
                        coeffDiff = abs(coeffArray[0] - coeffArray[1])
                        // составляем мапу диффов
                        diffMap[sv] = coeffDiff
                        
                    } else {
                        print("пизда")
                    }

                    
                }
            }
            print("======= diffMap ========")
            print(diffMap)
            
            // потом сортируем по diff18
            // составить мапу sv: diff18
            var diff18Map: [Float: Any] = [:]
            for sv in svArray {
                if let pair = handicapMap[specialValue] as? [[String: Any]] {
                    var coeffArray: [Float] = []
                    
                    for odd in pair {
                        if let coeff = odd["coefficient"] as? String {
                            if let floatCoeff = Float(coeff) {
                                coeffArray.append(floatCoeff)
                            }
                        } else {
                            coeffArray.append(0.0)
                        }
                    }
                    
                    if coeffArray.count > 1 {
                        let diff18_1 = abs(coeffArray[0] - 1.8)
                        let diff18_2 = abs(coeffArray[1] - 1.8)
                        
                        let diff18 = (diff18_1 + diff18_2) / 2.0
                        diff18Map[sv] = diff18
                    }
                }
            }
            print("======= diff18Map ========")
            print(diff18Map)
            
            // сортировать массив svArray по diff
            let svArraySortedByDiff = svArray.sorted {
                let diff_1 = diffMap[$0] as! Float
                let diff_2 = diffMap[$1] as! Float
                
                return diff_1 < diff_2
            }
            
            print(svArraySortedByDiff)
            
            // сортировать массив svArray по diff18
            let svArraySortedByDiff18 = svArray.sorted {
                let diff18_1 = diff18Map[$0] as! Float
                let diff18_2 = diff18Map[$1] as! Float
                
                return diff18_1 < diff18_2
            }
            
            print(svArraySortedByDiff18)
            
            // взять первый итем - это sv выигравшей пары
            let svForWinningPair = svArraySortedByDiff18.first!
            
            // перезаписываем в handicapMap выигравшую пару
            // записать ее с этим abs(sv) в handicapMap
            handicapMap[abs(svForWinningPair)] = svMap[svForWinningPair]
        }
        
        
        // 3). сортируем финальную мапу
        // - собираем handicapDiffMap
        // - собираем handicapDiff18Map
        // -
        
        for specialValue in absSpecialValues {
            print("=====================")
            print("\(specialValue): \(handicapMap[specialValue]!)")
            print("=====================")
        }
        
        var handicapDiffMap: [Float: Any] = [:]
        for specialValue in absSpecialValues {
            if let pair = handicapMap[specialValue] as? [[String: Any]] {
                var coeffDiff: Float = 0.0
                var coeffArray: [Float] = []
                
                for odd in pair {
                    if let coeff = odd["coefficient"] as? String {
                        if let floatCoeff = Float(coeff) {
                            coeffArray.append(floatCoeff)
                        }
                    } else {
                        coeffArray.append(0.0)
                    }
                }
                
                if coeffArray.count > 1 {
                    coeffDiff = abs(coeffArray[0] - coeffArray[1])
                    handicapDiffMap[specialValue] = coeffDiff
                }
            }
        }
        
        print("======= diffMap ========")
        print(handicapDiffMap)
        
        var handicapDiff18Map: [Float: Any] = [:]
        for specialValue in absSpecialValues {
            if let pair = handicapMap[specialValue] as? [[String: Any]] {
                var coeffArray: [Float] = []
                
                for odd in pair {
                    if let coeff = odd["coefficient"] as? String {
                        if let floatCoeff = Float(coeff) {
                            coeffArray.append(floatCoeff)
                        }
                    } else {
                        coeffArray.append(0.0)
                    }
                }
                
                if coeffArray.count > 1 {
                    let diff18_1 = abs(coeffArray[0] - 1.8)
                    let diff18_2 = abs(coeffArray[1] - 1.8)
                    
                    let diff18 = (diff18_1 + diff18_2) / 2
                    handicapDiff18Map[specialValue] = diff18
                }
            }
        }
        print("======= diff18Map ========")
        print(handicapDiff18Map)
        
        // сортируем массив absSpecialValue по diff
        let absSpecialValuesSortedByDiff = absSpecialValues.sorted {
            let diff_1 = handicapDiffMap[$0] as! Float
            let diff_2 = handicapDiffMap[$1] as! Float
            
            return diff_1 < diff_2
        }
        
        print(absSpecialValuesSortedByDiff)
        
        // сортируем массив absSpecialValue по diff18
        let absSpecialValuesSortedByDiff18 = absSpecialValues.sorted {
            let diff18_1 = handicapDiff18Map[$0] as! Float
            let diff18_2 = handicapDiff18Map[$1] as! Float
            
            return diff18_1 < diff18_2
        }
        print(absSpecialValuesSortedByDiff18)
        
  
        // взять первый итем - это sv выигравшей пары
        let svForWinningPair = absSpecialValuesSortedByDiff18.first!
        let winningPair = handicapMap[svForWinningPair] as! [[String: Any]]

        return winningPair
    }