package main

import (
    "fmt"
    "log"
    "net/http"
)

// homeHandler gelen isteklere "Merhaba, Go API!" yanıtını verir.
func homeHandler(w http.ResponseWriter, r *http.Request) {
    // HTTP başlığına Content-Type ekleyerek tarayıcıya/istemciye JSON döneceğimizi bildirebiliriz.
    // Şimdilik basit bir metin yanıtı dönüyoruz.
    // w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    fmt.Fprintf(w, "Merhaba, Go API!")
}

// aboutHandler Hakkımızda sayfası için basit bir metin yanıtı döner.
func aboutHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Bu Go ile oluşturulmuş basit bir API'dır.")
}

func main() {
    // `http.HandleFunc` kullanarak belirli URL yolları için handler'ları tanımlarız.
    // "/" kök yolu için `homeHandler`'ı kullan.
    http.HandleFunc("/", homeHandler)
    // "/about" yolu için `aboutHandler`'ı kullan.
    http.HandleFunc("/about", aboutHandler)

    // Sunucunun dinleyeceği portu ve kullanılacak handler'ı belirtiriz.
    // `nil` kullanmak, `http.DefaultServeMux`'ın kullanılacağı anlamına gelir.
    fmt.Println("Go API Sunucusu 8080 portunda dinleniyor...")
    // `log.Fatal` kullanarak sunucunun hata durumunda programı sonlandırmasını sağlarız.
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/mux" // Gorilla Mux kütüphanesini import ediyoruz
)

// getUserHandler, URL'den kullanıcı ID'sini alarak yanıt verir.
func getUserHandler(w http.ResponseWriter, r *http.Request) {
    // mux.Vars fonksiyonu ile URL'deki değişkenleri (parametreleri) alırız.
    vars := mux.Vars(r)
    userID := vars["id"] // "/users/{id}" şeklindeki tanımdan gelen "id" parametresi

    fmt.Fprintf(w, "Kullanıcı ID: %s", userID)
}

// createUserHandler, sadece POST isteklerini kabul eder.
func createUserHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusCreated) // HTTP 201 Created durum kodu döneriz.
    fmt.Fprintf(w, "Yeni kullanıcı oluşturuldu (POST isteği).")
}

func main() {
    // Yeni bir Mux router oluştururuz.
    router := mux.NewRouter()

    // "/users/{id}" yolunu tanımlarız. Sadece GET isteklerini kabul eder.
    router.HandleFunc("/users/{id}", getUserHandler).Methods("GET")
    // "/users" yolunu tanımlarız. Sadece POST isteklerini kabul eder.
    router.HandleFunc("/users", createUserHandler).Methods("POST")

    fmt.Println("Go API Sunucusu (Gorilla Mux ile) 8080 portunda dinleniyor...")
    log.Fatal(http.ListenAndServe(":8080", router)) // Router'ı HTTP sunucusuna iletiriz.
}

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil" // r.Body'yi okumak için
    "log"
    "net/http"
)

// User struct'ı, JSON verilerimizi temsil eder.
// `json:"..."` etiketleri, struct alanlarının JSON anahtarlarıyla nasıl eşleşeceğini belirtir.
type User struct {
    ID       string `json:"id"`
    Name     string `json:"name"`
    Email    string `json:"email"`
}

// getAllUsersHandler, örnek kullanıcı listesini JSON olarak döndürür.
func getAllUsersHandler(w http.ResponseWriter, r *http.Request) {
    users := []User{
        {"1", "Ali Can", "ali@example.com"},
        {"2", "Veli Demir", "veli@example.com"},
    }

    // HTTP yanıt başlığına Content-Type: application/json ekliyoruz.
    w.Header().Set("Content-Type", "application/json")
    // HTTP durum kodunu OK (200) olarak ayarlıyoruz (varsayılan zaten 200).
    // w.WriteHeader(http.StatusOK)

    // Kullanıcı listesini JSON'a dönüştürüp yanıt olarak yazıyoruz.
    if err := json.NewEncoder(w).Encode(users); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

// createUserWithJSONHandler, POST isteğiyle gelen JSON verisini ayrıştırır.
func createUserWithJSONHandler(w http.ResponseWriter, r *http.Request) {
    // İstek gövdesini okuyarak ham JSON verisini elde ederiz.
    body, err := ioutil.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "İstek gövdesi okunamadı.", http.StatusInternalServerError)
        return
    }
    defer r.Body.Close() // İstek gövdesini kapatmayı unutmayın.

    var newUser User
    // JSON verisini Go struct'ına dönüştürüyoruz (unmarshal).
    err = json.Unmarshal(body, &newUser)
    if err != nil {
        http.Error(w, "Geçersiz JSON formatı: "+err.Error(), http.StatusBadRequest)
        return
    }

    // Yeni kullanıcının bilgilerini konsola yazdırıyoruz.
    fmt.Printf("Yeni Kullanıcı Oluşturuldu: %+v\n", newUser)

    // İstemciye oluşturulan kullanıcıyı JSON olarak geri döndürüyoruz.
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated) // 201 Created
    if err := json.NewEncoder(w).Encode(newUser); err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
    }
}

func main() {
    // Bu kısım gorilla/mux ile daha iyi yönetilir. Basit örnek için böyle.
    // Router kullanarak HTTP metotlarına göre yönlendirme yapmak daha doğrudur.
    http.HandleFunc("/users-get", getAllUsersHandler) 
    http.HandleFunc("/users-post", createUserWithJSONHandler)
    fmt.Println("JSON API Sunucusu 8080 portunda dinleniyor...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "database/sql"
    "fmt"
    "log"

    // PostgreSQL sürücüsünü import ediyoruz. "_" ile import ederek paketin init fonksiyonunun çalışmasını sağlarız.
    _ "github.com/lib/pq"
)

// initDB, veritabanı bağlantısını kurar ve döndürür.
func initDB() *sql.DB {
    // Veritabanı bağlantı dizisi (Connection String). Kendi bilgilerinize göre düzenlemelisiniz.
    connStr := "user=go_user password=go_password dbname=go_db host=localhost sslmode=disable"
    
    // Veritabanı bağlantısını açar. İkinci parametre sürücünün adıdır.
    db, err := sql.Open("postgres", connStr)
    if err != nil {
        log.Fatalf("Veritabanı bağlantısı açılamadı: %v", err)
    }

    // Veritabanı bağlantısının gerçekten çalışıp çalışmadığını kontrol ederiz.
    if err = db.Ping(); err != nil {
        log.Fatalf("Veritabanına bağlanılamadı: %v", err)
    }

    fmt.Println("Veritabanı bağlantısı başarılı!")
    return db
}

// main fonksiyonunda bu bağlantıyı nasıl kullanabileceğimize dair basit bir örnek.
// Gerçek API'larda bu 'db' objesini handler fonksiyonlarınıza enjekte etmelisiniz.
// Örn: router.HandleFunc("/users", func(w http.ResponseWriter, r *http.Request) { getUsersHandler(w, r, db) })
// Veya bir struct'a yerleştirip metot olarak tanımlayabilirsiniz.
func main() {
    db := initDB()
    defer db.Close() // Uygulama bittiğinde veritabanı bağlantısını kapatırız.

    // Örnek bir sorgu çalıştırma
    var version string
    err := db.QueryRow("SELECT version()").Scan(&version)
    if err != nil {
        log.Fatalf("Sorgu çalıştırılamadı: %v", err)
    }
    fmt.Printf("Veritabanı Sürümü: %s\n", version)
}

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

// loggingMiddleware, gelen her isteği loglar.
func loggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now() // İsteğin başlangıç zamanı
        
        // Asıl handler'ı çağırırız.
        next.ServeHTTP(w, r) 
        
        // İstek tamamlandıktan sonra loglama yaparız.
        log.Printf("İstek tamamlandı - Metot: %s, Yol: %s, Süre: %v", r.Method, r.RequestURI, time.Since(start))
    })
}

// main fonksiyonunda nasıl kullanılacağı:
func main() {
    // Örnek bir handler
    myHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Merhaba, loglama yapıldı!")
    })

    // Middleware'i handler'ımıza uygularız.
    loggedHandler := loggingMiddleware(myHandler)

    http.Handle("/", loggedHandler)
    log.Println("Middleware'li Sunucu 8080 portunda dinleniyor...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

package main

import (
    "errors"
    "fmt"
    "net/http"
)

// divide fonksiyonu, sıfıra bölme durumunda hata döndürür.
func divide(a, b float64) (float64, error) {
    if b == 0 {
        // errors.New ile yeni bir hata oluştururuz.
        return 0, errors.New("sıfıra bölünemez")
    }
    return a / b, nil
}

// divisionHandler, API üzerinden bölme işlemi yapar ve hataları yönetir.
func divisionHandler(w http.ResponseWriter, r *http.Request) {
    // Örnek olarak sabit değerler kullanalım. Gerçekte URL query parametrelerinden alınabilir.
    num1 := 10.0
    num2 := 0.0 // Hata durumu için sıfır

    result, err := divide(num1, num2)
    if err != nil {
        // Hata durumunda HTTP 400 Bad Request veya 500 Internal Server Error dönebiliriz.
        http.Error(w, fmt.Sprintf("Bölme işlemi hatası: %s", err.Error()), http.StatusBadRequest)
        return
    }

    fmt.Fprintf(w, "Sonuç: %f", result)
}

func main() {
    http.HandleFunc("/divide", divisionHandler)
    fmt.Println("Hata Yönetimi Sunucusu 8080 portunda dinleniyor...")
    http.ListenAndServe(":8080", nil)
}

package main

import "fmt"

// APIError, özel API hata mesajlarını tutar.
type APIError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

func (e *APIError) Error() string {
    return fmt.Sprintf("API Hatası [Kod: %d]: %s", e.Code, e.Message)
}

// Örneğin, geçersiz bir kullanıcı ID'si hatası döndürmek için (User struct'ı daha önce tanımlanmış olmalı):
/*
func getUserByID(id string) (*User, error) {
    if id == "" {
        return nil, &APIError{Code: 400, Message: "Kullanıcı ID boş olamaz."}
    }
    // ... veritabanından kullanıcıyı alma mantığı ...
    // Eğer kullanıcı bulunamazsa:
    return nil, &APIError{Code: 404, Message: fmt.Sprintf("Kullanıcı '%s' bulunamadı.", id)}
}
*/

package main_test // main paketi için test paketi, "_test" eki ile ayrılır

import (
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"
)

// Test edeceğimiz createUserWithJSONHandler'ın basitleştirilmiş bir sürümü.
// Gerçekte main.go'daki handler'ı import edip kullanmalıyız.
// Ama BBCode içinde karmaşıklığı azaltmak ve bağımsız bir örnek sunmak için burada yeniden tanımlayalım.
type User struct { // Test için User struct'ını burada da tanımlamamız gerekebilir
    ID       string `json:"id"`
    Name     string `json:"name"`
    Email    string `json:"email"`
}

func createUserWithJSONHandler(w http.ResponseWriter, r *http.Request) {
    var user User
    err := json.NewDecoder(r.Body).Decode(&user)
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusCreated)
    json.NewEncoder(w).Encode(user)
}

func TestCreateUserWithJSONHandler(t *testing.T) {
    // Test için örnek bir JSON payload'ı oluşturuyoruz.
    payload := `{"id": "1", "name": "Ayşe Yılmaz", "email": "ayse@example.com"}`
    
    // HTTP isteğini simüle etmek için `httptest.NewRequest` kullanıyoruz.
    req, err := http.NewRequest("POST", "/users", strings.NewReader(payload))
    if err != nil {
        t.Fatal(err) // Hata olursa testi durdur.
    }
    req.Header.Set("Content-Type", "application/json") // İçerik tipini belirtiyoruz.

    // `httptest.NewRecorder` kullanarak yanıtı kaydetmek için bir "response recorder" oluşturuyoruz.
    rr := httptest.NewRecorder()
    
    // Test edeceğimiz handler'ı çağırıyoruz.
    handler := http.HandlerFunc(createUserWithJSONHandler)
    handler.ServeHTTP(rr, req) // Handler'ı kaydedici ve istek ile çalıştır.

    // HTTP durum kodunu kontrol ediyoruz.
    if status := rr.Code; status != http.StatusCreated { // Beklenen 201 Created
        t.Errorf("Handler yanlış durum kodu döndürdü: Beklenen %v, Alınan %v",
            http.StatusCreated, status)
    }

    // Yanıt gövdesini kontrol ediyoruz.
    expected := `{"id":"1","name":"Ayşe Yılmaz","email":"ayse@example.com"}`
    // Dönüşte boşluk veya yeni satır karakterleri olabileceği için TrimSpace kullanmak iyi bir pratik.
    if strings.TrimSpace(rr.Body.String()) != expected {
        t.Errorf("Handler beklenmeyen yanıt gövdesi döndürdü: Beklenen %v, Alınan %v",
            expected, strings.TrimSpace(rr.Body.String()))
    }
}