import UIKit
import Foundation

/// --------- 1-st task ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

var autos: [String: Int] = ["audi": 100,
                            "ford": 200,
                            "opel": 300]

var autosSecondArray: [String: Int] = ["lada": 300,
                             "cherry": 299,
                             "kalina": 239]

let limitOfPower = 150 // задаем лимит

// It is a nested function in the next function
// This function print information: should a car pay a tax or not
func shouldWePayATaxes(autoes: [String: Int]) {
    // look at the autoes
    for nameOfAuto in autoes.keys{  // проходимся по всему словарю
        if let powerOfAuto = autoes[nameOfAuto] { // если можем достать значение по ключу без ошибки
            if powerOfAuto >= limitOfPower { // если значение больше либо равно лимиту
                print("Name of auto that should pay a tax: \(nameOfAuto)") // выводим название авто у которого превышен лимит по лошадиным силам
            }
        }
    }
}


// Function Of Count Of Power Of Autos
func sumOfAllPowerOfAuto(autoes: [String: Int], limitOfPower: Int) {
    // считем сумму всех лошадей и добавляем эту сумму к новому N-му авто
    var sum = 0 // сумма лошадей
    for element in autoes.keys{
        sum += autoes[element]! // суммируем все лошадиные силы
        autos["lada"] = sum // записываем сумму всех лошадей в авто "лада"
    }

    // средняя мощь авто
    let avPower: Double = Double(sum) / Double(autoes.count) // count average power
    print("Average amount of power: \(avPower)")

    shouldWePayATaxes(autoes: autoes)
}

// first call
sumOfAllPowerOfAuto(autoes: autos, limitOfPower: limitOfPower)

// second call
sumOfAllPowerOfAuto(autoes: autosSecondArray, limitOfPower: limitOfPower)


/// --------- 2-е задание ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

let one: Int? = 1
let two: Int? = 123
let three: Int? = 777

func unbiding(number: Int?, typeOfUnbiding: Int) {
    switch typeOfUnbiding {
    case 1:
        // 1-nd type
        if number! != nil {
           print("Первый способ вложенности: \(number!)")
        }
    case 2:
        // 2-rd type
        if let chislo = two {
            print("Второй способ вложенности: \(chislo)")
        }
    default:
        // 3-rd type
        let tmp = three ?? 0
        print("Третий способ вложенности: \(tmp)")
    }
}

// first call
unbiding(number: one, typeOfUnbiding: 1)

// second call
unbiding(number: two, typeOfUnbiding: 2)

// third call
unbiding(number: three, typeOfUnbiding: 3)



/// --------4-nd task --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

let lozungTuple = (1, "Labour", true)

func concatinationOfStrings(tuple: (Int, String, Bool), typeOfcreatingString: Int){
    switch typeOfcreatingString {
    case 1:
        // 1. First type with "+" concatenation
        let firstTypeOfConcatenation = String(tuple.0) + " " + tuple.1 + " " + String(tuple.2)
        print(firstTypeOfConcatenation)
    case 2:
        // 2. Second type with \()
        let secondTypeOfConcatenation = ("Peace \(tuple.1) May")
        print(secondTypeOfConcatenation)
    default:
        // 3. Third type with %@
        let thirdTypeOfConcatenationFormatString = "%@ %@ %@"
        let newString = String(format: thirdTypeOfConcatenationFormatString, String(tuple.0), tuple.1, String(tuple.2))
        print(newString)
    }
}

concatinationOfStrings(tuple: lozungTuple, typeOfcreatingString: 1)
concatinationOfStrings(tuple: lozungTuple, typeOfcreatingString: 2)
concatinationOfStrings(tuple: lozungTuple, typeOfcreatingString: 3)


/// --------5-th task --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

// Массив опциональных интов, либо Нилами. В цикле посчитайте сумму
// Один любой способ разворачивания optional (который считаете более правильным)


// 5. Task of Optional Int?
var arrayOfOptionalInt:[Int?] = [nil]

// 5.2 Summarise all elements
func printOptionalIntSumm(arrayOfInt: inout [Int?]) {
    // 5.1 Initializate 100 random elements
    for _ in 0...100 {
        arrayOfInt.append(Int.random(in: 1...100))
    }

    var sumOfAllElements = 0

    for elementOfMassive in arrayOfInt {
        if let unbindingElement = elementOfMassive {
            sumOfAllElements += unbindingElement
        }
    }
    print(sumOfAllElements)
}

// 5.3 Print result

printOptionalIntSumm(arrayOfInt: &arrayOfOptionalInt)
printOptionalIntSumm(arrayOfInt: &arrayOfOptionalInt)


/// --------6-th task --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
// Пройти в цикле по строке. Записать каждый character в другую строку таким образом, чтобы получилось реверс строка. То есть с обратной записью

// 6. Reverse a string
let firstString = "ABCDEFG"
let secondString = "TUTTA LARSEN"

func reverseAString(string: String) {
    var newString = "" // create final string
    var numerator = string.count - 1 // create numerator

    while(numerator >= 0) {
        newString.append(Array(string)[numerator])
        numerator -= 1
    }
    print(newString)
}

// call function
reverseAString(string: firstString)
reverseAString(string: secondString)


/// --------7-th task --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------