class Participant: CustomStringConvertible {
        var name = "noname"
        var contact = "nocontact"
        var giveTo:Participant?
        init(name:String,contact:String){
            self.name = name
            self.contact = contact
        }
        var description: String {return name + ((giveTo==nil) ?"":"->\(giveTo!.name)")}
    }

    class Group: CustomDebugStringConvertible {
        static var allGroups:[Group]=[]
        static var counter = 0
        var participants:[Participant]=[]
        var name = "G-x"
        var description:String {return name}
        var debugDescription:String {return name}
        init(participants:[Participant]){
            self.participants=participants
            name = "G-\(Group.counter++)"
            Group.allGroups.append(self)
            Group.allGroups = Group.sortGroups(Group.allGroups)
        }

        func size()->Int{return self.participants.count}

        func getRandParticipant()->Participant{
            let p = participants[Int(arc4random_uniform(UInt32(participants.count)))]
            return p
        }

        func remove(p:Participant)->Bool{
            let originalIndex = participants.count
            participants = participants.filter() { $0.name != p.name }
            return originalIndex != participants.count
        }

        static func sortGroups(g:[Group])->[Group]{
            //remove groups with size = 0
            let rg = g.filter() {return $0.size()>0}
            //sort
            return rg.sort() {return $0.0.size()>$0.1.size()}
        }

        static func getRandGroup(groups:[Group])->Group{
            return groups[Int(arc4random_uniform(UInt32(groups.count)))]
        }

        static func removeFromGroups(groups:[Group],p:Participant)->[Group]{
            for g in groups{
                if(g.remove(p)){
                    break;
                }
            }
            return sortGroups(groups)
        }

        static func getPairs(groups:[Group])->[Participant]{
            var groups2consume = groups
            var giverGroup = getRandGroup(groups2consume)
            var searchIn:[Group]
            var giver:Participant = giverGroup.getRandParticipant()
            let first = giver
            var returnArray:[Participant] = []
            while(groups2consume.count>0){
                let indexO = groups2consume.indexOf() {$0.name==giverGroup.name}
                if let index = indexO{
                    if (index>0){
                        //if giverGroup is 0 it means it is in the largest group
                        searchIn = [groups2consume[0]]
                    }else if groups2consume.count>1{
                        //if giverGroup is not 0 and the count is >0 then there are smaller groups
                        searchIn = groups2consume
                        searchIn.removeFirst()
                    }else{
                        //there is only one group left
                        searchIn = groups2consume
                        searchIn[0].remove(giver)
                    }
                    if searchIn[0].participants.count>0{
                        let receiverGroup = getRandGroup(searchIn)
                        let receiver = receiverGroup.getRandParticipant()
                        groups2consume = removeFromGroups(groups2consume, p: giver)
                        giver.giveTo=receiver
                        returnArray.append(giver)
                        giverGroup = receiverGroup
                        giver = receiver
                    }else{
                        groups2consume = removeFromGroups(groups2consume, p: giver)
                    }
                }else{
                    break
                }
            }
            giver.giveTo=first
            returnArray.append(giver)
            return returnArray
        }
    }