/**
 * Beispiel aus
 *
 * - Algorithmen und Datenstrukturen für Dummies
 *   - von Andreas Gogol-Döring und Thomas Letschert
 *   - Verlag Wiley-VCH; Oktober 2019
 *  - Kapitel 7, Sortieren
 *
 * @author A. Gogol-Döring, Th. Letschert
 */

import Foundation

struct AuD_07_01_SelectionSortOrdered {

    static func SelectionSort_natOrderComparable<A: Comparable>(a: inout [A], l: Int, r: Int) {

        func argmin(i: Int, j: Int) ->Int {
            var m = i
            if (r > i) {
                for j in i+1 ... r {if (a[j] < a[m]) {m = j}}
            }
            return m
        }

        func swap(i: Int, j: Int) {
            let t = a[i]
            a[i] = a[j]
            a[j] = t
        }

        for i in l ..< r {
            let m = argmin(i: i, j: r)
            swap(i: i, j: m)
        }
    }

    struct ComparableWorker: Comparable, CustomStringConvertible {
        let name: String
        let weight: Int
        static func < (lhs: ComparableWorker, rhs: ComparableWorker) -> Bool {
            lhs.weight < rhs.weight
        }
        var description: String { "[\(name), \(weight)]" }
    }

    static var comparableWorkers: [ComparableWorker] = [
        ComparableWorker(name: "Alex",    weight: 77),
        ComparableWorker(name: "Bert",    weight: 72),
        ComparableWorker(name: "Klausi",  weight: 96), 
        ComparableWorker(name: "Dominik", weight: 111),
        ComparableWorker(name: "Emil",    weight: 96),   
        ComparableWorker(name: "Flo",     weight: 122),
        ComparableWorker(name: "Gerd",    weight: 75)
    ]

    static func run() {
        SelectionSort_natOrderComparable(a: &comparableWorkers, l: 0, r: comparableWorkers.count-1)
        print(comparableWorkers.map( { w in w.description} ).joined(separator: ","))
    }

}