OKEY 101 OYUNUN KOD DOKUMANI

  func encode(b []byte) string {
      return base64.StdEncoding.EncodeToString(b)
  }
        

  func decode(s string) ([]byte, error) {
      data, err := base64.StdEncoding.DecodeString(s)
      if err != nil {
          return nil, err
      }
      return data, nil
  }
        

  func Encrypt(text, MySecret string) (string, error) {
      block, err := aes.NewCipher([]byte(MySecret))
      if err != nil {
          return "", err
      }
      plainText := []byte(text)
      cfb := cipher.NewCFBEncrypter(block, bytes)
      cipherText := make([]byte, len(plainText))
      cfb.XORKeyStream(cipherText, plainText)
      return encode(cipherText), nil
  }
        

  func Decrypt(text, MySecret string) (string, error) {
      block, err := aes.NewCipher([]byte(MySecret))
      if err != nil {
          return "", err
      }
      cipherText, err := decode(text)
      if err != nil {
          return "", err
      }
      cfb := cipher.NewCFBDecrypter(block, bytes)
      plainText := make([]byte, len(cipherText))
      cfb.XORKeyStream(plainText, cipherText)
      return string(plainText), nil
  }
        

  func HashAndSalt(pwd []byte) string {
      hash, err := bcrypt.GenerateFromPassword(pwd, bcrypt.MinCost)
      if err != nil {
          log.Println(err)
      }
      return string(hash)
  }
        

  func ComparePasswords(hashedPwd string, plainPwd []byte) bool {
      byteHash := []byte(hashedPwd)
      err := bcrypt.CompareHashAndPassword(byteHash, plainPwd)
      if err != nil {
          log.Println(err)
          return false
      }
      return true
  }
        

  // OkeyTaşınıBelirle, gösterge taşına göre gerçek okey taşını döner
  func DetermineOkeyTile(indicator Model.Tile) Model.Tile {
      nextNumber := indicator.Number + 1 // Gösterge numarasının bir fazlası alınır

      if nextNumber > 13 {               // Okey taş numarası 13'ü aşarsa 1'e sarar
          nextNumber = 1
      }

      return Model.Tile{                 // Gerçek okey taşı nesnesi döndürülür
          Number:  nextNumber,           // Hesaplanan numara
          Color:   indicator.Color,      // Gösterge taşıyla aynı renk
          IsOkey:  true,                 // Bu taş gerçek okeydir
          IsJoker: false,                // Joker değildir
      }
  }
        

  func (tiles *TileBag) MarkOkeyTiles(indicator Model.Tile) {
      okey := DetermineOkeyTile(indicator) // Gösterge taşına göre gerçek okey belirlenir

      for i := range *tiles {              // Tüm taş torbası gezilir
          tile := &(*tiles)[i]             // İlgili taşın referansı alınır

          if tile.Number == indicator.Number && tile.Color == indicator.Color {
              // Bu taş gösterge taşıysa sahte okey olur
              tile.IsJoker = true          // Sahte okey olarak işaretlenir
              tile.IsOkey = false          // Gerçek okey olmadığı belirtilir
          } else if tile.Number == okey.Number && tile.Color == okey.Color && !tile.IsJoker {
              // Bu taş gerçek okey taşına eşitse ve joker değilse
              tile.IsOkey = true           // Gerçek okey olarak işaretlenir
          } else if tile.Number == 0 && tile.Color == ColorEnum.None && tile.IsJoker {
              // Ön tanımlı renksiz-numarasız joker taşlar
              tile.Number = okey.Number    // Gerçek okeyin numarası atanır
              tile.Color = okey.Color      // Gerçek okeyin rengi atanır
          } else {
              // Diğer tüm taşlar için sıfırlama yapılır
              tile.IsOkey = false
              tile.IsJoker = false
          }
      }
  }
        

  func CreateFullTileSet() TileBag {
      var tiles []Model.Tile // Taşları tutacak ana liste
      id := 0                // Her taşa atanacak benzersiz ID
      colors := []int{
          ColorEnum.Red,
          ColorEnum.Yellow,
          ColorEnum.Blue,
          ColorEnum.Black,
      }
      for _, color := range colors {          // Tüm renkler için
          for number := 1; number <= 13; number++ { // 1–13 arası sayılar
              for i := 0; i < 2; i++ {         // Her renkten 2 taş
                  tiles = append(tiles, Model.Tile{
                      ID:      id,
                      Number:  number,
                      Color:   color,
                      IsJoker: false,
                      IsOkey:  false,
                      IsOpend: false,
                  })
                  id++
              }
          }
      }
      // 2 adet sahte okey taşı (renksiz, numbersız)
      for i := 0; i < 2; i++ {
          tiles = append(tiles, Model.Tile{
              ID:      id,
              Number:  0,
              Color:   ColorEnum.None,
              IsJoker: true,
              IsOkey:  false,
          })
          id++
      }
      return ShuffleTilesSecure(tiles) // Taşları karıştırarak döndür
  }
        

  // Fisher-Yates Shuffle :)
  // ShuffleTilesSecure, taşları kriptografik olarak güvenli şekilde karıştırır
  func ShuffleTilesSecure(tiles []Model.Tile) TileBag {
      shuffled := make([]Model.Tile, len(tiles)) // Yeni boş bir dizi oluştur
      copy(shuffled, tiles)                      // Orijinal taşları kopyala

      for i := len(shuffled) - 1; i > 0; i-- {    // Diziyi sondan başa gez
          j, err := cryptoRandInt(i + 1)         // 0–i arasında güvenli bir sayı üret
          if err != nil {
              // Hata durumunda karıştırılmadan orijinal dizi döner
              return tiles
          }
          shuffled[i], shuffled[j] = shuffled[j], shuffled[i] // i ve j indekslerini yer değiştir
      }

      return shuffled // Karıştırılmış diziyi döndür
  }
        

  // cryptoRandInt returns a random int between 0 and max-1 using crypto/rand
  func cryptoRandInt(max int) (int, error) {
      nBig, err := rand.Int(rand.Reader, big.NewInt(int64(max))) // Büyük sayı üretimi
      if err != nil {
          return 0, err // Hata varsa varsayılan 0 döndürülür
      }
      return int(nBig.Int64()), nil // Güvenli sayı int'e çevrilerek döndürülür
  }
        

  func (tiles *TileBag) GetTiles(count int) *TileBag {
      if len(*tiles) < count {
          count = len(*tiles) // Taş sayısı yetersizse, kalan kadarını al
      }

      selected := (*tiles)[:count]      // Seçilen taşlar
      *tiles = (*tiles)[count:]         // Geriye kalan taşları TileBag'e geri yaz

      return &selected                  // Seçilen taşları geri döndür
  }
        

  func ShowPlayerTiles(tiles *TileBag, name string, topCount int) *TileBag {
      player := tiles.GetTiles(topCount) // Belirtilen sayıda taşı al

      fmt.Println(name) // Oyuncu adı yazdırılır
      fmt.Println(strings.Repeat("-", 30)) // Görsel ayraç

      for i, tile := range *player {
          colorName := GetEnumName(ColorEnum, tile.Color) // Renk ismini al
          fmt.Printf("%d-) ID: %d, %s %d, Joker: %v Okey: %v\n",
              i+1, tile.ID, colorName, tile.Number, tile.IsJoker, tile.IsOkey)
      }

      fmt.Println() // Satır atla
      fmt.Printf("Kalan taş sayısı: %d\n", len(*tiles)) // TileBag'deki taş sayısını yazdır

      return player // Oyuncuya verilen taşlar döndürülür
  }
        

  func (tiles *TileBag) GetRandomIndicatorFromTiles() Model.Tile {
      validTiles := make([]Model.Tile, 0) // Joker olmayan taşlar için boş bir liste oluştur

      for _, tile := range *tiles {
          if !tile.IsJoker {
              validTiles = append(validTiles, tile) // Joker olmayanları ekle
          }
      }

      if len(validTiles) == 0 {
          log.Fatal("TileBag contains no valid (non-Joker) tiles for indicator selection")
      }

      max := big.NewInt(int64(len(validTiles))) // Liste boyutunu BigInt olarak al
      n, err := rand.Int(rand.Reader, max)      // Rastgele index üret (crypto güvenli)
      if err != nil {
          log.Fatalf("crypto/rand failed: %v", err) // Hata varsa programı durdur
      }

      randomIndex := int(n.Int64()) // Rastgele index'e karşılık gelen taş alınır
      indicator := validTiles[randomIndex]

      DropTileFromTiles((*[]Model.Tile)(tiles), indicator) // Seçilen taş torbadan çıkarılır

      return indicator // Gösterge taşı döndürülür
  }
        

  func (tiles *TileBag) TakeOneFromBag(player *[]Model.Tile) Model.Tile {
      if len(*tiles) == 0 {
          log.Fatal("TileBag contains no valid (non-Joker) tiles for indicator selection") // Boşsa hata ver
      }

      var tile = (*tiles)[0]       // İlk taşı seç
      *tiles = (*tiles)[1:]        // TileBag'den çıkar
      *player = append(*player, tile) // Oyuncunun taş listesine ekle

      return tile                  // Seçilen taşı döndür
  }
        

  func TakeOneFromTable(player *[]Model.Tile, tile Model.Tile) {
      *player = append(*player, tile) // Taşı oyuncuya ekle
  }
        

  func DropTileFromTiles(playerTiles *[]Model.Tile, dropTile Model.Tile) bool {
      var isFound bool = false                      // Taşın bulunup bulunmadığını tutar

      for i, tile := range *playerTiles {           // Oyuncunun elindeki taşları döngüyle tara
          if tile.ID == dropTile.ID {               // ID eşleşiyorsa
              *playerTiles = append(                // Bu index'teki taşı çıkar
                  (*playerTiles)[:i],
                  (*playerTiles)[i+1:]...,
              )
              isFound = true                        // Bulundu ve silindi
              break
          }
      }

      return isFound                                // Sonuç olarak true veya false döndür
  }
        

  func FloatPtr(f float64) *float64 {
      return &f // f'nin adresini döndür (pointer)
  }
        

  func IntPtr(i int) *int {
      return &i // i'nin adresini döndür
  }
        

  func BoolPtr(b bool) *bool {
      return &b // b değerinin adresini döndür
  }
        

  var Game GameGroupState

  func ResetGame() {
      Game = GameGroupState{
          GroupIDCounter: 0, // Sayacı sıfırla
      }
  }
        

  // Global oyun durumu
  var Game GameGroupState

  // Oyun grup bilgilerini tutar
  type GameGroupState struct {
      GroupIDCounter int // Grup ID üretimi için sayaç
  }
        

  func (g *GameGroupState) GenerateGroupID() int {
      g.GroupIDCounter++             // Sayaç 1 artırılır
      return g.GroupIDCounter        // Yeni grup ID değeri döndürülür
  }
        

func IsValidGroupOrRun(tiles []*Model.Tile) bool {
    if len(tiles) < 3 {
        return false
    }

    okeyCount := countOkeys(tiles)               // Joker (okey) taşlarını sayar
    nonOkeyTiles := filterNonOkeys(tiles)        // Gerçek taşları ayıklar

    // Grup veya sıralı dizi kontrolü yapılır
    return isGroup(nonOkeyTiles, okeyCount) || isSequence(nonOkeyTiles, okeyCount)
}
      

// Örnek: Kırmızı 5, Mavi 5, Sarı 5
func isGroup(tiles []*Model.Tile, okeyCount int) bool {
    if len(tiles) == 0 {
        return false
    }

    number := tiles[0].Number               // Tüm taşların bu sayıya sahip olması gerekir
    colors := make(map[int]bool)           // Kullanılan renkleri takip etmek için map

    for _, tile := range tiles {
        if tile.Number != number || colors[tile.Color] {
            return false                   // Farklı sayı veya tekrar eden renk varsa geçersiz
        }
        colors[tile.Color] = true
    }

    return len(tiles) + okeyCount >= 3     // Toplam (taş + joker) en az 3 olmalı
}
      

// Örnek: Siyah 3, Siyah 4, Siyah 5
func isSequence(tiles []*Model.Tile, okeyCount int) bool {
    if len(tiles) == 0 {
        return false
    }

    // Aynı renkte değillerse seri olamaz
    if !allSameColor(tiles) {
        return false
    }

    // Sayı sıralamasına göre sırala
    sort.Slice(tiles, func(i, j int) bool {
        return tiles[i].Number < tiles[j].Number
    })

    // Eksik taşlar için gereken joker sayısını hesapla
    neededOkeys := calculateNeededOkeysForRun(tiles, okeyCount)

    // Joker yetmiyorsa veya toplam sayı yetersizse geçersiz
    return neededOkeys <= okeyCount && len(tiles) + okeyCount >= 3
}
      

func calculateNeededOkeysForRun(tiles []*Model.Tile, maxOkeys int) int {
    neededOkeys := 0
    for i := 1; i < len(tiles); i++ {
        diff := tiles[i].Number - tiles[i-1].Number
        switch diff {
        case 1:
            continue // Arada boşluk yoksa
        case 2:
            neededOkeys++ // 1 boşluk → 1 joker gerekir
        case 3:
            neededOkeys += 2 // 2 boşluk → 2 joker gerekir
        default:
            return maxOkeys + 1 // Çok büyük boşluk varsa geçersiz
        }
    }
    return neededOkeys
}
      

func countOkeys(tiles []*Model.Tile) int {
    count := 0
    for _, tile := range tiles {
        if tile.IsOkey {
            count++
        }
    }
    return count
}
      

func filterNonOkeys(tiles []*Model.Tile) []*Model.Tile {
    result := make([]*Model.Tile, 0, len(tiles))
    for _, tile := range tiles {
        if !tile.IsOkey {
            result = append(result, tile)
        }
    }
    return result
}
      

func allSameColor(tiles []*Model.Tile) bool {
    if len(tiles) == 0 {
        return true
    }
    color := tiles[0].Color
    for _, tile := range tiles {
        if tile.Color != color {
            return false
        }
    }
    return true
}
      

func CalculateTileScore(tile *Model.Tile, index int, tiles []*Model.Tile, isSequence bool) int {
    if !tile.IsOkey {
        return tile.Number
    }

    if !isSequence {
        for _, t := range tiles {
            if !t.IsOkey {
                return t.Number
            }
        }
        return tile.Number
    }

    nonOkeys := filterNonOkeys(tiles)
    if len(nonOkeys) == 0 {
        return 1
    }

    sort.Slice(nonOkeys, func(i, j int) bool {
        return nonOkeys[i].Number < nonOkeys[j].Number
    })

    numbers := []int{}
    for _, t := range nonOkeys {
        numbers = append(numbers, t.Number)
    }

    for i := 0; i < len(numbers)-1; i++ {
        if numbers[i+1]-numbers[i] > 1 {
            return numbers[i] + 1
        }
    }

    if numbers[len(numbers)-1] < 13 {
        if index == 0 {
            return numbers[0] - 1
        } else {
            return numbers[len(numbers)-1] + 1
        }
    }

    if numbers[0] > 1 {
        return numbers[0] - 1
    }

    return 1
}
      

func CanOpenTiles(opened [][]*Model.Tile) bool {
    totalScore := 0
    for _, group := range opened {

        // İçlerinde zaten açılmış taş varsa hata döner
        if HasOpenTail(group...) {
            return false
        }

        // Grup geçerli mi kontrol edilir
        if !IsValidGroupOrRun(group) {
            return false
        }

        isSeq := isSequence(filterNonOkeys(group), countOkeys(group))
        for index, tile := range group {
            totalScore += CalculateTileScore(tile, index, group, isSeq)
        }
    }

    var result = totalScore >= 101

    // Eğer toplam skor uygunsa, taşları açık olarak işaretle
    if result {
        SetOpentiles(opened)
    }

    return result
}
      

func CanOpenTilesWithRemaining(tiles []*Model.Tile, opened [][]*Model.Tile) (remaining []*Model.Tile, score int, error bool) {
    totalScore := 0
    var remainList []*Model.Tile

    for _, group := range opened {
        if HasOpenTail(group...) {
            return remainList, 0, false
        }

        if !IsValidGroupOrRun(group) {
            return remainList, 0, false
        }

        isSeq := isSequence(filterNonOkeys(group), countOkeys(group))
        for index, tile := range group {
            totalScore += CalculateTileScore(tile, index, group, isSeq)
        }
    }

    var result = totalScore > 0

    if result {
        remainList = getRemainingInOpenedTiles(tiles, opened)
    }

    return remainList, totalScore, result
}
      

func CanOpenTilesWithRemainingWithAllGroups(groups [][]*Model.Tile) 
    (opened [][]*Model.Tile, remaining [][]*Model.Tile, score int, error bool) {

    totalScore := 0
    var remainList [][]*Model.Tile
    var openedList [][]*Model.Tile

    for _, group := range groups {
        if HasOpenTail(group...) {
            return openedList, remainList, 0, false
        }

        if !IsValidGroupOrRun(group) {
            remainList = append(remainList, group)
        } else {
            openedList = append(openedList, group)
            isSeq := isSequence(filterNonOkeys(group), countOkeys(group))
            for index, tile := range group {
                totalScore += CalculateTileScore(tile, index, group, isSeq)
            }
        }
    }

    var result = totalScore > 0
    return openedList, remainList, totalScore, result
}
      

func getRemainingInOpenedTiles(tiles []*Model.Tile, opened [][]*Model.Tile) (remaining []*Model.Tile) {
    type pairKey struct {
        Color  int
        Number int
    }

    used := make(map[pairKey][]*Model.Tile)
    var remainList []*Model.Tile

    for _, group := range opened {
        for _, tile := range group {
            key := pairKey{Color: tile.Color, Number: tile.Number}
            used[key] = append(used[key], tile)
        }
    }

    for _, tile := range tiles {
        key := pairKey{Color: tile.Color, Number: tile.Number}
        if usedList, ok := used[key]; ok && len(usedList) > 0 {
            used[key] = usedList[1:]
        } else {
            remainList = append(remainList, tile)
        }
    }

    return remainList
}
      

func SetOpentiles(opened [][]*Model.Tile) {
    for _, group := range opened {
        //101'i geçen elde açılan tüm array gruplara ayrı ayrı unique groupID tanımlanır.
        var groupID = Game.GenerateGroupID()
        for _, tile := range group {
            tile.IsOpend = true
            tile.GroupID = &groupID
        }
    }
}
      

func SetOpenPairtiles(setTiles []*Model.Tile, grpID ...int) {
    var groupID int
    if len(grpID) > 0 {
        groupID = grpID[0]
    } else {
        groupID = Game.GenerateGroupID()
    }
    for _, tile := range setTiles {
        tile.IsOpend = true
        tile.GroupID = &groupID
    }
}
      

func HasOpenTail(tiles ...*Model.Tile) bool {
    for _, tile := range tiles {
        if tile.IsOpend {
            return true
        }
    }
    return false
}
      

func HasAtLeastFivePairs(opened [][]*Model.Tile) bool {
    pairCount := 0

    for _, group := range opened {
        if len(group) == 2 {
            tile1, tile2 := group[0], group[1]

            if HasOpenTail(tile1, tile2) {
                return false
            }

            if tile1.IsJoker && tile2.IsJoker {
                return false
            }

            score1 := CalculateTileScore(tile1, 0, group, false)
            score2 := CalculateTileScore(tile2, 1, group, false)

            if score1 == score2 {
                if tile1.IsOkey || tile2.IsOkey || tile1.Color == tile2.Color {
                    pairCount++
                } else {
                    return false
                }
            } else {
                return false
            }
        }
    }

    var result = pairCount >= 5
    if result {
        SetOpentiles(opened)
    }
    return result
}
      

func HasAtLeastFivePairsForSetNewPair(opened [][]*Model.Tile) bool {
    pairCount := 0

    for _, group := range opened {
        if len(group) == 2 {
            tile1, tile2 := group[0], group[1]

            if tile1.IsJoker && tile2.IsJoker {
                return false
            }

            score1 := CalculateTileScore(tile1, 0, group, false)
            score2 := CalculateTileScore(tile2, 1, group, false)

            if score1 == score2 {
                if tile1.IsOkey || tile2.IsOkey || tile1.Color == tile2.Color {
                    pairCount++
                } else {
                    return false
                }
            } else {
                return false
            }
        }
    }

    var result = pairCount >= 5
    return result
}
      

func CanAddTilesToSet(set []*Model.Tile, tiles ...*Model.Tile) bool {
    if len(tiles) == 0 || len(set) == 0 || len(tiles) > 2 || len(set) < 3 {
        return false
    }

    if HasOpenTail(tiles...) {
        return false
    }

    newSet := append([]*Model.Tile{}, set...)
    newSet = append(newSet, tiles...)

    var result = IsValidGroupOrRun(newSet)
    if result {
        SetOpenPairtiles(newSet, *set[0].GroupID)
    }
    return result
}
      

func TryAddTilesToSet(set *[]*Model.Tile, tiles ...*Model.Tile) bool {
    if len(tiles) == 0 || len(*set) == 0 || len(tiles) > 2 || len(*set) < 3 {
        return false
    }

    if HasOpenTail(tiles...) {
        return false
    }

    newSet := append([]*Model.Tile{}, *set...)
    newSet = append(newSet, tiles...)

    if IsValidGroupOrRun(newSet) {
        *set = append(*set, tiles...)
        SetOpenPairtiles(*set, *(*set)[0].GroupID)
        *set = sortGroupByEffectiveNumber(*set)
        return true
    }
    return false
}
      

func IsValidPair(tiles []*Model.Tile) bool {
    if len(tiles) != 2 {
        return false
    }

    if HasOpenTail(tiles...) {
        return false
    }

    tile1, tile2 := tiles[0], tiles[1]

    if tile1.IsJoker && tile2.IsJoker {
        return false
    }

    score1 := CalculateTileScore(tile1, 0, tiles, false)
    score2 := CalculateTileScore(tile2, 1, tiles, false)

    if score1 != score2 {
        return false
    }

    return tile1.IsOkey || tile2.IsOkey || tile1.Color == tile2.Color
}
      

func CanAddPairToPairSets(remaining []*Model.Tile, pairSets [][]*Model.Tile) bool {
    if IsValidPair(remaining) {
        var result = HasAtLeastFivePairsForSetNewPair(pairSets)
        if result {
            SetOpenPairtiles(remaining)
        }
        return result
    }
    return false
}
      

func CanThrowingTileBeAddedToOpponentSets(newPair *Model.Tile, opponentSets [][]*Model.Tile) bool {
    if newPair.IsOpend {
        //Acilan tas bir daha atilamaz.
        return false
    }
    for _, set := range opponentSets {
        if CanAddTilesToSet(set, newPair) {
            return true
        }
    }
    return false
}
      

func SplitTilesByValidGroupsOrRuns(tiles []*Model.Tile, maxGroupSizeOptional ...int) ([][]*Model.Tile, []*Model.Tile, int) {
    n := len(tiles)
    maxGroupSize := 5
    if len(maxGroupSizeOptional) > 0 && maxGroupSizeOptional[0] > 0 {
        maxGroupSize = maxGroupSizeOptional[0]
    }
    if n < maxGroupSize {
        maxGroupSize = n
    }

    sort.Slice(tiles, func(i, j int) bool {
        if tiles[i].Color == tiles[j].Color {
            return tiles[i].Number < tiles[j].Number
        }
        return tiles[i].Color < tiles[j].Color
    })

    type candidate struct {
        Indices []int
        Group   []*Model.Tile
    }

    var allGroups []candidate

    for size := maxGroupSize; size >= 3; size-- {
        indices := make([]int, size)
        var generate func(start, depth int)
        generate = func(start, depth int) {
            if depth == size {
                group := make([]*Model.Tile, size)
                okeyCount := 0
                for i, idx := range indices {
                    tile := tiles[idx]
                    group[i] = tile
                    if tile.IsOkey {
                        okeyCount++
                    }
                }
                if okeyCount > 2 {
                    return
                }
                nonOkeys := filterNonOkeys(group)
                if isGroup(nonOkeys, okeyCount) || isSequence(nonOkeys, okeyCount) {
                    tmp := make([]*Model.Tile, len(group))
                    copy(tmp, group)
                    tmpIdx := make([]int, len(indices))
                    copy(tmpIdx, indices)
                    allGroups = append(allGroups, candidate{Indices: tmpIdx, Group: tmp})
                }
                return
            }
            for i := start; i <= n-(size-depth); i++ {
                indices[depth] = i
                generate(i+1, depth+1)
            }
        }
        generate(0, 0)
    }

    var (
        maxTilesUsed    int
        maxScore        int
        bestCombination [][]*Model.Tile
    )

    var backtrack func(start int, used map[int]bool, current [][]*Model.Tile)
    backtrack = func(start int, used map[int]bool, current [][]*Model.Tile) {
        usedCount := len(used)
        score := 0
        for _, group := range current {
            score += sumGroupScore(group)
        }
        if usedCount > maxTilesUsed || (usedCount == maxTilesUsed && score > maxScore) {
            maxTilesUsed = usedCount
            maxScore = score
            bestCombination = deepCopyGroups(current)
        }

        for i := start; i < len(allGroups); i++ {
            canUse := true
            for _, idx := range allGroups[i].Indices {
                if used[idx] {
                    canUse = false
                    break
                }
            }
            if !canUse {
                continue
            }
            for _, idx := range allGroups[i].Indices {
                used[idx] = true
            }
            backtrack(i+1, used, append(current, allGroups[i].Group))
            for _, idx := range allGroups[i].Indices {
                delete(used, idx)
            }
        }
    }

    backtrack(0, make(map[int]bool), [][]*Model.Tile{})

    usedIndices := make(map[*Model.Tile]bool)
    for _, group := range bestCombination {
        for _, tile := range group {
            usedIndices[tile] = true
        }
    }

    var remaining []*Model.Tile
    for _, tile := range tiles {
        if !usedIndices[tile] {
            remaining = append(remaining, tile)
        }
    }

    for i, g := range bestCombination {
        bestCombination[i] = sortGroupByEffectiveNumber(g)
    }

    return bestCombination, remaining, maxScore
}

func deepCopyGroups(groups [][]*Model.Tile) [][]*Model.Tile {
    copied := make([][]*Model.Tile, len(groups))
    for i := range groups {
        copied[i] = make([]*Model.Tile, len(groups[i]))
        copy(copied[i], groups[i])
    }
    return copied
}

func sumGroupScore(group []*Model.Tile) int {
    isSeq := isSequence(filterNonOkeys(group), countOkeys(group))
    total := 0
    for i, tile := range group {
        total += CalculateTileScore(tile, i, group, isSeq)
    }
    return total
}

func sumAllGroupsNumbers(groups [][]*Model.Tile) int {
    total := 0
    for _, group := range groups {
        isSeq := isSequence(filterNonOkeys(group), countOkeys(group))
        for index, tile := range group {
            total += CalculateTileScore(tile, index, group, isSeq)
        }
    }
    return total
}

func getEffectiveNumber(tile *Model.Tile, group []*Model.Tile) int {
    if tile.IsOkey {
        nonOkeys := filterNonOkeys(group)

        if isGroup(nonOkeys, countOkeys(group)) {
            for _, t := range nonOkeys {
                return t.Number
            }
        } else if isSequence(nonOKeys, countOkeys(group)) {
            nums := []int{}
            for _, t := range nonOkeys {
                nums = append(nums, t.Number)
            }
            sort.Ints(nums)
            expected := nums[0]
            for _, n := range nums {
                if n != expected {
                    return expected
                }
                expected++
            }
            if expected > 13 {
                return nums[0] - 1
            }
            return expected
        }
    }
    return tile.Number
}

func sortGroupByEffectiveNumber(group []*Model.Tile) []*Model.Tile {
    type tileWithValue struct {
        tile  *Model.Tile
        value int
    }

    var withValues []tileWithValue
    for _, t := range group {
        withValues = append(withValues, tileWithValue{
            tile:  t,
            value: getEffectiveNumber(t, group),
        })
    }

    sort.SliceStable(withValues, func(i, j int) bool {
        return withValues[i].value < withValues[j].value
    })

    var sorted []*Model.Tile
    for _, tw := range withValues {
        sorted = append(sorted, tw.tile)
    }
    return sorted
}
      

func SplitTilesByValidPairs(tiles []*Model.Tile) ([][]*Model.Tile, []*Model.Tile) {
    type pairKey struct {
        Color  int
        Number int
    }

    grouped := make(map[pairKey][]*Model.Tile)
    var okeys []*Model.Tile

    for _, tile := range tiles {
        if tile.IsOkey {
            okeys = append(okeys, tile)
        } else {
            key := pairKey{Color: tile.Color, Number: tile.Number}
            grouped[key] = append(grouped[key], tile)
        }
    }

    var pairs [][]*Model.Tile
    used := make(map[*Model.Tile]bool)

    for _, group := range grouped {
        available := []*Model.Tile{}
        for _, t := range group {
            if !used[t] {
                available = append(available, t)
            }
        }
        for len(available) >= 2 {
            pair := available[:2]
            pairs = append(pairs, pair)
            used[pair[0]] = true
            used[pair[1]] = true
            available = available[2:]
        }
    }

    for _, group := range grouped {
        if len(okeys) == 0 {
            break
        }
        available := []*Model.Tile{}
        for _, t := range group {
            if !used[t] {
                available = append(available, t)
            }
        }
        for len(available) >= 1 && len(okeys) > 0 {
            t := available[0]
            okey := okeys[0]
            pairs = append(pairs, []*Model.Tile{t, okey})
            used[t] = true
            used[okey] = true
            available = available[1:]
            okeys = okeys[1:]
        }
    }

    var remaining []*Model.Tile
    for _, t := range tiles {
        if !used[t] {
            remaining = append(remaining, t)
        }
    }

    return pairs, remaining
}
      

var Game GameGroupState

type GameGroupState struct {
    GroupIDCounter int
}

func ResetGame() {
    Game = GameGroupState{
        GroupIDCounter: 0,
    }
}

// Örnek çağrı:
Core.ResetGame()

      

func TakeOneFromTable(player *[]Model.Tile, tile Model.Tile) {
    *player = append(*player, tile)
}

// Örnek çağrım:
// Player 2, dropTile adındaki taşı masadan alır
Core.TakeOneFromTable((*[]Model.Tile)(player2), dropTile)

      

func DropTileFromTiles(playerTiles *[]Model.Tile, dropTile Model.Tile) bool {
    var isFound bool = false
    for i, tile := range *playerTiles {
        if tile.ID == dropTile.ID {
            *playerTiles = append((*playerTiles)[:i], (*playerTiles)[i+1:]...)
            isFound = true
            break
        }
    }
    return isFound
}

// Örnek çağrım:
// Player 2, elindeki 5. taşı atar
Core.DropTileFromTiles((*[]Model.Tile)(player2), (*player2)[4])

      

func ShowPlayerTiles(tiles *TileBag, name string, topCount int) *TileBag {
    player := tiles.GetTiles(topCount)

    fmt.Println(name)
    fmt.Println(strings.Repeat("-", 30))

    for i, tile := range *player {
        colorName := GetEnumName(ColorEnum, tile.Color)
        fmt.Printf("%d-) ID: %d, %s %d, Joker: %v Okey: %v\n", 
            i+1, tile.ID, colorName, tile.Number, tile.IsJoker, tile.IsOkey)
    }

    fmt.Println()
    fmt.Printf("Kalan taş sayısı: %d\n", len(*tiles))
    return player
}

// Örnek çağrım:
// Player 1’e 22 taş verilip, bilgileri yazdırılır.
Core.ShowPlayerTiles(player1, "Player 1:", 22)

      

func ShowPlayerTiles(tiles *TileBag, name string, topCount int) *TileBag {
    player := tiles.GetTiles(topCount)

    fmt.Println(name)
    fmt.Println(strings.Repeat("-", 30))

    for i, tile := range *player {
        colorName := GetEnumName(ColorEnum, tile.Color)
        fmt.Printf("%d-) ID: %d, %s %d, Joker: %v Okey: %v\n", 
            i+1, tile.ID, colorName, tile.Number, tile.IsJoker, tile.IsOkey)
    }

    fmt.Println()
    fmt.Printf("Kalan taş sayısı: %d\n", len(*tiles))
    return player
}

// Kullanım örneği:
// Player 2 için 21 taş dağıtılır ve konsola yazdırılır.
Core.ShowPlayerTiles(player2, "Player 2:", 21)

      

func ShowPlayerTiles(tiles *TileBag, name string, topCount int) *TileBag {
    player := tiles.GetTiles(topCount)

    fmt.Println(name)
    fmt.Println(strings.Repeat("-", 30))

    for i, tile := range *player {
        colorName := GetEnumName(ColorEnum, tile.Color)
        fmt.Printf("%d-) ID: %d, %s %d, Joker: %v Okey: %v\n", 
            i+1, tile.ID, colorName, tile.Number, tile.IsJoker, tile.IsOkey)
    }

    fmt.Println()
    fmt.Printf("Kalan taş sayısı: %d\n", len(*tiles))
    return player
}

// Örnek kullanım:
Core.ShowPlayerTiles(&tiles, "Bag :", len(tiles))