package main

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

func main() {
    // 간단한 GET 요청
    resp, err := http.Get("https://api.github.com/users/golang")
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close() // 반드시 닫아줘야 해!

    // 응답 본문 읽기
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("응답 읽기 실패:", err)
        return
    }

    fmt.Println("상태 코드:", resp.StatusCode)
    fmt.Println("응답 내용:", string(body))
}

package main

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

func main() {
    // 커스텀 클라이언트 생성
    client := &http.Client{
        Timeout: 10 * time.Second, // 10초 타임아웃
    }

    // 요청 객체 생성
    req, err := http.NewRequest("GET", "https://api.github.com/users/golang", nil)
    if err != nil {
        fmt.Println("요청 생성 실패:", err)
        return
    }

    // 헤더 추가
    req.Header.Add("User-Agent", "My-Go-Client/1.0")
    req.Header.Add("Accept", "application/json")

    // 요청 실행
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("응답:", string(body))
}

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age"`
}

func main() {
    // 전송할 데이터 준비
    user := User{
        Name:  "홍길동",
        Email: "hong@example.com",
        Age:   25,
    }

    // JSON으로 인코딩
    jsonData, err := json.Marshal(user)
    if err != nil {
        fmt.Println("JSON 인코딩 실패:", err)
        return
    }

    // POST 요청 전송
    resp, err := http.Post(
        "https://jsonplaceholder.typicode.com/users",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close()

    // 응답 확인
    body, _ := io.ReadAll(resp.Body)
    fmt.Println("상태 코드:", resp.StatusCode)
    fmt.Println("응답:", string(body))
}

package main

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

func main() {
    // 1. API 키를 쿼리 파라미터로 전달
    apiKeyURL := "https://api.example.com/data?api_key=YOUR_API_KEY"
    
    // 2. Bearer 토큰 인증
    client := &http.Client{}
    req, _ := http.NewRequest("GET", "https://api.example.com/protected", nil)
    req.Header.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN")
    
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close()

    // 3. Basic Authentication
    req2, _ := http.NewRequest("GET", "https://api.example.com/basic", nil)
    req2.SetBasicAuth("username", "password")
    
    resp2, err := client.Do(req2)
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp2.Body.Close()

    body, _ := io.ReadAll(resp2.Body)
    fmt.Println("응답:", string(body))
}

import "os"

func main() {
    apiKey := os.Getenv("API_KEY")
    if apiKey == "" {
        fmt.Println("API_KEY 환경 변수가 설정되지 않았습니다")
        return
    }
    
    // apiKey 사용...
}

package main

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

func main() {
    // 커스텀 Transport 설정
    transport := &http.Transport{
        // 연결 풀 설정
        MaxIdleConns:        100,              // 전체 유휴 연결 수
        MaxIdleConnsPerHost: 10,               // 호스트당 유휴 연결 수
        MaxConnsPerHost:     100,              // 호스트당 최대 연결 수
        
        // 타임아웃 세부 설정
        DialContext: (&net.Dialer{
            Timeout:   5 * time.Second,  // 연결 타임아웃
            KeepAlive: 30 * time.Second, // Keep-Alive 주기
        }).DialContext,
        
        TLSHandshakeTimeout:   10 * time.Second,
        ResponseHeaderTimeout: 10 * time.Second,
        ExpectContinueTimeout: 1 * time.Second,
        
        // 유휴 연결 정리 주기
        IdleConnTimeout: 90 * time.Second,
    }

    client := &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second,
    }

    // 이 클라이언트로 여러 요청을 보내면
    // 연결이 재사용되어 성능이 향상돼!
    for i := 0; i < 10; i++ {
        resp, err := client.Get("https://api.github.com/users/golang")
        if err != nil {
            fmt.Println("요청 실패:", err)
            continue
        }
        fmt.Println("요청", i+1, "완료:", resp.StatusCode)
        resp.Body.Close()
    }
}

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "time"
)

func main() {
    // 5초 타임아웃 컨텍스트 생성
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    // 컨텍스트를 포함한 요청 생성
    req, err := http.NewRequestWithContext(
        ctx,
        "GET",
        "https://httpbin.org/delay/10", // 10초 걸리는 API
        nil,
    )
    if err != nil {
        fmt.Println("요청 생성 실패:", err)
        return
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // 타임아웃이나 취소 시 에러 발생
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("응답:", string(body))
}

// 수동 취소 예제
func manualCancelExample() {
    ctx, cancel := context.WithCancel(context.Background())
    
    // 3초 후 취소
    go func() {
        time.Sleep(3 * time.Second)
        cancel()
        fmt.Println("요청 취소!")
    }()

    req, _ := http.NewRequestWithContext(ctx, "GET", "https://httpbin.org/delay/10", nil)
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("요청이 취소되었습니다:", err)
        return
    }
    defer resp.Body.Close()
}

package main

import (
    "bytes"
    "context"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

// API 클라이언트 구조체
type APIClient struct {
    BaseURL    string
    HTTPClient *http.Client
    APIKey     string
}

// 클라이언트 생성자
func NewAPIClient(baseURL, apiKey string) *APIClient {
    return &APIClient{
        BaseURL: baseURL,
        APIKey:  apiKey,
        HTTPClient: &http.Client{
            Timeout: 30 * time.Second,
            Transport: &http.Transport{
                MaxIdleConnsPerHost: 10,
                IdleConnTimeout:     90 * time.Second,
            },
        },
    }
}

// GET 요청 헬퍼 메서드
func (c *APIClient) Get(ctx context.Context, endpoint string, result interface{}) error {
    url := c.BaseURL + endpoint
    
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return fmt.Errorf("요청 생성 실패: %w", err)
    }

    // 공통 헤더 설정
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Accept", "application/json")

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    // 상태 코드 확인
    if resp.StatusCode != http.StatusOK {
        body, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("API 에러 (코드: %d): %s", resp.StatusCode, string(body))
    }

    // JSON 디코딩
    if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
        return fmt.Errorf("JSON 디코딩 실패: %w", err)
    }

    return nil
}

// POST 요청 헬퍼 메서드
func (c *APIClient) Post(ctx context.Context, endpoint string, payload, result interface{}) error {
    url := c.BaseURL + endpoint

    // 페이로드를 JSON으로 인코딩
    jsonData, err := json.Marshal(payload)
    if err != nil {
        return fmt.Errorf("JSON 인코딩 실패: %w", err)
    }

    req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return fmt.Errorf("요청 생성 실패: %w", err)
    }

    // 공통 헤더 설정
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("Accept", "application/json")

    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    // 상태 코드 확인 (200, 201 모두 성공)
    if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
        body, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("API 에러 (코드: %d): %s", resp.StatusCode, string(body))
    }

    // 응답이 있으면 디코딩
    if result != nil {
        if err := json.NewDecoder(resp.Body).Decode(result); err != nil {
            return fmt.Errorf("JSON 디코딩 실패: %w", err)
        }
    }

    return nil
}

// 사용 예제
type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
}

func main() {
    // 클라이언트 생성
    client := NewAPIClient("https://api.example.com", "your-api-key")

    // GET 요청 예제
    ctx := context.Background()
    var user User
    err := client.Get(ctx, "/users/1", &user)
    if err != nil {
        fmt.Println("사용자 조회 실패:", err)
        return
    }
    fmt.Printf("사용자 정보: %+v\n", user)

    // POST 요청 예제
    newUser := User{
        Name:  "김개발",
        Email: "kim@example.com",
    }
    var createdUser User
    err = client.Post(ctx, "/users", newUser, &createdUser)
    if err != nil {
        fmt.Println("사용자 생성 실패:", err)
        return
    }
    fmt.Printf("생성된 사용자: %+v\n", createdUser)
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

// API 에러 응답 구조체
type APIError struct {
    StatusCode int    `json:"status_code"`
    Message    string `json:"message"`
    ErrorCode  string `json:"error_code"`
}

func (e *APIError) Error() string {
    return fmt.Sprintf("API 에러 [%d] %s: %s", e.StatusCode, e.ErrorCode, e.Message)
}

// 재시도 로직을 포함한 요청 함수
func requestWithRetry(url string, maxRetries int) (*http.Response, error) {
    var resp *http.Response
    var err error

    client := &http.Client{
        Timeout: 10 * time.Second,
    }

    for i := 0; i < maxRetries; i++ {
        resp, err = client.Get(url)
        
        // 성공하면 바로 반환
        if err == nil && resp.StatusCode == http.StatusOK {
            return resp, nil
        }

        // 실패 시 로그 출력
        if err != nil {
            fmt.Printf("시도 %d/%d 실패: %v\n", i+1, maxRetries, err)
        } else {
            fmt.Printf("시도 %d/%d 실패: 상태 코드 %d\n", i+1, maxRetries, resp.StatusCode)
            resp.Body.Close()
        }

        // 마지막 시도가 아니면 대기
        if i < maxRetries-1 {
            waitTime := time.Duration(i+1) * time.Second
            fmt.Printf("%v 후 재시도...\n", waitTime)
            time.Sleep(waitTime)
        }
    }

    if err != nil {
        return nil, fmt.Errorf("최대 재시도 횟수 초과: %w", err)
    }
    return resp, fmt.Errorf("최대 재시도 횟수 초과: 상태 코드 %d", resp.StatusCode)
}

// 상태 코드별 처리
func handleResponse(resp *http.Response) error {
    defer resp.Body.Close()

    switch resp.StatusCode {
    case http.StatusOK, http.StatusCreated:
        // 성공
        return nil
        
    case http.StatusBadRequest:
        // 잘못된 요청
        body, _ := io.ReadAll(resp.Body)
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    string(body),
            ErrorCode:  "BAD_REQUEST",
        }
        
    case http.StatusUnauthorized:
        // 인증 실패
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    "인증이 필요합니다",
            ErrorCode:  "UNAUTHORIZED",
        }
        
    case http.StatusForbidden:
        // 권한 없음
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    "접근 권한이 없습니다",
            ErrorCode:  "FORBIDDEN",
        }
        
    case http.StatusNotFound:
        // 리소스 없음
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    "요청한 리소스를 찾을 수 없습니다",
            ErrorCode:  "NOT_FOUND",
        }
        
    case http.StatusTooManyRequests:
        // 요청 제한 초과
        retryAfter := resp.Header.Get("Retry-After")
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    fmt.Sprintf("요청 제한 초과. %s 후 재시도하세요", retryAfter),
            ErrorCode:  "RATE_LIMIT",
        }
        
    case http.StatusInternalServerError:
        // 서버 에러
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    "서버 내부 오류가 발생했습니다",
            ErrorCode:  "INTERNAL_ERROR",
        }
        
    default:
        // 기타 에러
        body, _ := io.ReadAll(resp.Body)
        return &APIError{
            StatusCode: resp.StatusCode,
            Message:    string(body),
            ErrorCode:  "UNKNOWN_ERROR",
        }
    }
}

func main() {
    // 재시도 로직 사용 예제
    resp, err := requestWithRetry("https://api.github.com/users/golang", 3)
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }

    // 응답 처리
    if err := handleResponse(resp); err != nil {
        fmt.Println("응답 처리 실패:", err)
        return
    }

    fmt.Println("요청 성공!")
}

package main

import (
    "bytes"
    "fmt"
    "io"
    "mime/multipart"
    "net/http"
    "os"
    "path/filepath"
)

// 파일 업로드 함수
func uploadFile(url, fieldName, filePath string) error {
    // 파일 열기
    file, err := os.Open(filePath)
    if err != nil {
        return fmt.Errorf("파일 열기 실패: %w", err)
    }
    defer file.Close()

    // 멀티파트 폼 데이터 생성
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // 파일 필드 추가
    part, err := writer.CreateFormFile(fieldName, filepath.Base(filePath))
    if err != nil {
        return fmt.Errorf("폼 파일 생성 실패: %w", err)
    }

    // 파일 내용 복사
    if _, err := io.Copy(part, file); err != nil {
        return fmt.Errorf("파일 복사 실패: %w", err)
    }

    // 추가 필드 (선택사항)
    writer.WriteField("description", "업로드된 파일입니다")
    writer.WriteField("category", "documents")

    // Writer 닫기 (중요!)
    if err := writer.Close(); err != nil {
        return fmt.Errorf("writer 닫기 실패: %w", err)
    }

    // HTTP 요청 생성
    req, err := http.NewRequest("POST", url, body)
    if err != nil {
        return fmt.Errorf("요청 생성 실패: %w", err)
    }

    // Content-Type 헤더 설정 (boundary 포함)
    req.Header.Set("Content-Type", writer.FormDataContentType())

    // 요청 전송
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    // 응답 확인
    if resp.StatusCode != http.StatusOK {
        bodyBytes, _ := io.ReadAll(resp.Body)
        return fmt.Errorf("업로드 실패 (코드: %d): %s", resp.StatusCode, string(bodyBytes))
    }

    fmt.Println("파일 업로드 성공!")
    return nil
}

// 여러 파일 동시 업로드
func uploadMultipleFiles(url string, files map[string]string) error {
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)

    // 각 파일 추가
    for fieldName, filePath := range files {
        file, err := os.Open(filePath)
        if err != nil {
            return fmt.Errorf("파일 열기 실패 (%s): %w", filePath, err)
        }

        part, err := writer.CreateFormFile(fieldName, filepath.Base(filePath))
        if err != nil {
            file.Close()
            return fmt.Errorf("폼 파일 생성 실패: %w", err)
        }

        _, err = io.Copy(part, file)
        file.Close()
        if err != nil {
            return fmt.Errorf("파일 복사 실패: %w", err)
        }
    }

    writer.Close()

    req, err := http.NewRequest("POST", url, body)
    if err != nil {
        return fmt.Errorf("요청 생성 실패: %w", err)
    }

    req.Header.Set("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    fmt.Println("모든 파일 업로드 완료!")
    return nil
}

func main() {
    // 단일 파일 업로드
    err := uploadFile(
        "https://example.com/upload",
        "file",
        "/path/to/document.pdf",
    )
    if err != nil {
        fmt.Println("업로드 실패:", err)
        return
    }

    // 여러 파일 업로드
    files := map[string]string{
        "document": "/path/to/document.pdf",
        "image":    "/path/to/image.jpg",
        "video":    "/path/to/video.mp4",
    }
    err = uploadMultipleFiles("https://example.com/upload-multiple", files)
    if err != nil {
        fmt.Println("다중 업로드 실패:", err)
    }
}

package main

import (
    "crypto/tls"
    "crypto/x509"
    "fmt"
    "io"
    "net/http"
    "os"
)

// 기본 HTTPS 클라이언트
func basicHTTPSClient() {
    // 기본 설정으로도 HTTPS는 자동으로 처리돼
    resp, err := http.Get("https://api.github.com")
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Println("HTTPS 요청 성공!")
}

// 커스텀 TLS 설정
func customTLSClient() {
    tlsConfig := &tls.Config{
        // 최소 TLS 버전 설정
        MinVersion: tls.VersionTLS12,
        
        // 선호하는 암호화 스위트
        CipherSuites: []uint16{
            tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
            tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
        },
        
        // 인증서 검증 (프로덕션에서는 true여야 함!)
        InsecureSkipVerify: false,
    }

    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://api.github.com")
    if err != nil {
        fmt.Println("요청 실패:", err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Println("커스텀 TLS 설정으로 요청 성공!")
}

// 자체 서명 인증서 사용 (개발 환경)
func selfSignedCertClient(certFile string) error {
    // 인증서 파일 읽기
    caCert, err := os.ReadFile(certFile)
    if err != nil {
        return fmt.Errorf("인증서 읽기 실패: %w", err)
    }

    // 인증서 풀 생성
    caCertPool := x509.NewCertPool()
    if !caCertPool.AppendCertsFromPEM(caCert) {
        return fmt.Errorf("인증서 파싱 실패")
    }

    // TLS 설정
    tlsConfig := &tls.Config{
        RootCAs: caCertPool,
    }

    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://localhost:8443")
    if err != nil {
        return fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println("응답:", string(body))
    return nil
}

// 클라이언트 인증서 사용 (mTLS)
func mutualTLSClient(certFile, keyFile, caFile string) error {
    // 클라이언트 인증서 로드
    cert, err := tls.LoadX509KeyPair(certFile, keyFile)
    if err != nil {
        return fmt.Errorf("클라이언트 인증서 로드 실패: %w", err)
    }

    // CA 인증서 로드
    caCert, err := os.ReadFile(caFile)
    if err != nil {
        return fmt.Errorf("CA 인증서 읽기 실패: %w", err)
    }

    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)

    // TLS 설정
    tlsConfig := &tls.Config{
        Certificates: []tls.Certificate{cert},
        RootCAs:      caCertPool,
    }

    transport := &http.Transport{
        TLSClientConfig: tlsConfig,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://secure-api.example.com")
    if err != nil {
        return fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    fmt.Println("mTLS 인증 성공!")
    return nil
}

func main() {
    // 기본 HTTPS
    basicHTTPSClient()

    // 커스텀 TLS
    customTLSClient()

    // 자체 서명 인증서 (예제)
    // selfSignedCertClient("./ca.crt")

    // mTLS (예제)
    // mutualTLSClient("./client.crt", "./client.key", "./ca.crt")
}

package main

import (
    "context"
    "fmt"
    "io"
    "net/http"
    "sync"
    "time"
)

// 요청 결과 구조체
type Result struct {
    URL      string
    Status   int
    Body     string
    Duration time.Duration
    Error    error
}

// 단일 URL 요청 함수
func fetchURL(ctx context.Context, url string) Result {
    start := time.Now()
    result := Result{URL: url}

    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        result.Error = err
        return result
    }

    client := &http.Client{Timeout: 10 * time.Second}
    resp, err := client.Do(req)
    if err != nil {
        result.Error = err
        result.Duration = time.Since(start)
        return result
    }
    defer resp.Body.Close()

    result.Status = resp.StatusCode
    body, _ := io.ReadAll(resp.Body)
    result.Body = string(body)
    result.Duration = time.Since(start)

    return result
}

// 여러 URL 병렬 요청 (채널 사용)
func fetchMultipleURLs(urls []string) []Result {
    results := make([]Result, len(urls))
    resultChan := make(chan Result, len(urls))

    ctx := context.Background()

    // 각 URL에 대해 고루틴 시작
    for _, url := range urls {
        go func(u string) {
            resultChan <- fetchURL(ctx, u)
        }(url)
    }

    // 결과 수집
    for i := 0; i < len(urls); i++ {
        results[i] = <-resultChan
    }

    return results
}

// WaitGroup을 사용한 병렬 요청
func fetchWithWaitGroup(urls []string) []Result {
    var wg sync.WaitGroup
    results := make([]Result, len(urls))
    ctx := context.Background()

    for i, url := range urls {
        wg.Add(1)
        go func(index int, u string) {
            defer wg.Done()
            results[index] = fetchURL(ctx, u)
        }(i, url)
    }

    wg.Wait()
    return results
}

// 동시 요청 수 제한 (워커 풀 패턴)
func fetchWithWorkerPool(urls []string, maxWorkers int) []Result {
    jobs := make(chan string, len(urls))
    results := make(chan Result, len(urls))

    ctx := context.Background()

    // 워커 시작
    var wg sync.WaitGroup
    for i := 0; i < maxWorkers; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for url := range jobs {
                results <- fetchURL(ctx, url)
            }
        }()
    }

    // 작업 전송
    for _, url := range urls {
        jobs <- url
    }
    close(jobs)

    // 워커 종료 대기
    go func() {
        wg.Wait()
        close(results)
    }()

    // 결과 수집
    var finalResults []Result
    for result := range results {
        finalResults = append(finalResults, result)
    }

    return finalResults
}

// 타임아웃이 있는 병렬 요청
func fetchWithTimeout(urls []string, timeout time.Duration) []Result {
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    results := make([]Result, len(urls))
    var wg sync.WaitGroup

    for i, url := range urls {
        wg.Add(1)
        go func(index int, u string) {
            defer wg.Done()
            results[index] = fetchURL(ctx, u)
        }(i, url)
    }

    wg.Wait()
    return results
}

func main() {
    urls := []string{
        "https://api.github.com/users/golang",
        "https://api.github.com/users/kubernetes",
        "https://api.github.com/users/docker",
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://jsonplaceholder.typicode.com/posts/2",
    }

    fmt.Println("=== 순차 요청 ===")
    start := time.Now()
    for _, url := range urls {
        result := fetchURL(context.Background(), url)
        fmt.Printf("%s: %d (%v)\n", result.URL, result.Status, result.Duration)
    }
    fmt.Printf("총 소요 시간: %v\n\n", time.Since(start))

    fmt.Println("=== 병렬 요청 (채널) ===")
    start = time.Now()
    results := fetchMultipleURLs(urls)
    for _, result := range results {
        if result.Error != nil {
            fmt.Printf("%s: 에러 - %v\n", result.URL, result.Error)
        } else {
            fmt.Printf("%s: %d (%v)\n", result.URL, result.Status, result.Duration)
        }
    }
    fmt.Printf("총 소요 시간: %v\n\n", time.Since(start))

    fmt.Println("=== 워커 풀 (동시 요청 2개 제한) ===")
    start = time.Now()
    results = fetchWithWorkerPool(urls, 2)
    for _, result := range results {
        if result.Error != nil {
            fmt.Printf("%s: 에러 - %v\n", result.URL, result.Error)
        } else {
            fmt.Printf("%s: %d (%v)\n", result.URL, result.Status, result.Duration)
        }
    }
    fmt.Printf("총 소요 시간: %v\n\n", time.Since(start))

    fmt.Println("=== 타임아웃 5초 ===")
    start = time.Now()
    results = fetchWithTimeout(urls, 5*time.Second)
    for _, result := range results {
        if result.Error != nil {
            fmt.Printf("%s: 에러 - %v\n", result.URL, result.Error)
        } else {
            fmt.Printf("%s: %d (%v)\n", result.URL, result.Status, result.Duration)
        }
    }
    fmt.Printf("총 소요 시간: %v\n", time.Since(start))
}

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
    "time"
)

// 날씨 데이터 구조체
type WeatherResponse struct {
    Location struct {
        Name    string `json:"name"`
        Country string `json:"country"`
    } `json:"location"`
    Current struct {
        TempC     float64 `json:"temp_c"`
        Condition struct {
            Text string `json:"text"`
        } `json:"condition"`
        Humidity int     `json:"humidity"`
        WindKph  float64 `json:"wind_kph"`
    } `json:"current"`
}

// 날씨 API 클라이언트
type WeatherClient struct {
    BaseURL    string
    APIKey     string
    HTTPClient *http.Client
}

// 클라이언트 생성
func NewWeatherClient(apiKey string) *WeatherClient {
    return &WeatherClient{
        BaseURL: "https://api.weatherapi.com/v1",
        APIKey:  apiKey,
        HTTPClient: &http.Client{
            Timeout: 15 * time.Second,
            Transport: &http.Transport{
                MaxIdleConnsPerHost: 5,
                IdleConnTimeout:     60 * time.Second,
            },
        },
    }
}

// 현재 날씨 조회
func (c *WeatherClient) GetCurrentWeather(ctx context.Context, city string) (*WeatherResponse, error) {
    // URL 파라미터 구성
    params := url.Values{}
    params.Add("key", c.APIKey)
    params.Add("q", city)
    params.Add("aqi", "no")

    fullURL := fmt.Sprintf("%s/current.json?%s", c.BaseURL, params.Encode())

    // 요청 생성
    req, err := http.NewRequestWithContext(ctx, "GET", fullURL, nil)
    if err != nil {
        return nil, fmt.Errorf("요청 생성 실패: %w", err)
    }

    // 헤더 설정
    req.Header.Set("Accept", "application/json")

    // 요청 실행
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, fmt.Errorf("요청 실패: %w", err)
    }
    defer resp.Body.Close()

    // 상태 코드 확인
    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API 에러: 상태 코드 %d", resp.StatusCode)
    }

    // JSON 디코딩
    var weather WeatherResponse
    if err := json.NewDecoder(resp.Body).Decode(&weather); err != nil {
        return nil, fmt.Errorf("JSON 디코딩 실패: %w", err)
    }

    return &weather, nil
}

// 여러 도시의 날씨 동시 조회
func (c *WeatherClient) GetMultipleCitiesWeather(ctx context.Context, cities []string) map[string]*WeatherResponse {
    results := make(map[string]*WeatherResponse)
    resultChan := make(chan struct {
        city    string
        weather *WeatherResponse
        err     error
    }, len(cities))

    // 각 도시에 대해 고루틴 시작
    for _, city := range cities {
        go func(c string) {
            weather, err := c.GetCurrentWeather(ctx, c)
            resultChan <- struct {
                city    string
                weather *WeatherResponse
                err     error
            }{c, weather, err}
        }(city)
    }

    // 결과 수집
    for i := 0; i < len(cities); i++ {
        result := <-resultChan
        if result.err == nil {
            results[result.city] = result.weather
        } else {
            fmt.Printf("도시 %s 조회 실패: %v\n", result.city, result.err)
        }
    }

    return results
}

// 날씨 정보 출력
func printWeather(city string, weather *WeatherResponse) {
    fmt.Printf("\n🌍 %s, %s\n", weather.Location.Name, weather.Location.Country)
    fmt.Printf("🌡️  온도: %.1f°C\n", weather.Current.TempC)
    fmt.Printf("☁️  날씨: %s\n", weather.Current.Condition.Text)
    fmt.Printf("💧 습도: %d%%\n", weather.Current.Humidity)
    fmt.Printf("💨 풍속: %.1f km/h\n", weather.Current.WindKph)
}

func main() {
    // API 키는 환경 변수에서 가져오는 게 좋아
    apiKey := "YOUR_API_KEY_HERE"
    
    client := NewWeatherClient(apiKey)
    ctx := context.Background()

    // 단일 도시 조회
    fmt.Println("=== 서울 날씨 조회 ===")
    weather, err := client.GetCurrentWeather(ctx, "Seoul")
    if err != nil {
        fmt.Println("날씨 조회 실패:", err)
        return
    }
    printWeather("Seoul", weather)

    // 여러 도시 동시 조회
    fmt.Println("\n=== 여러 도시 날씨 동시 조회 ===")
    cities := []string{"Seoul", "Tokyo", "New York", "London", "Paris"}
    
    start := time.Now()
    results := client.GetMultipleCitiesWeather(ctx, cities)
    duration := time.Since(start)

    for city, weather := range results {
        printWeather(city, weather)
    }

    fmt.Printf("\n⏱️  총 소요 시간: %v (병렬 처리)\n", duration)
}

package main

import (
    "context"
    "fmt"
    "io"
    "math"
    "net/http"
    "time"
)

// 레이트 리미터 구조체
type RateLimiter struct {
    ticker   *time.Ticker
    requests chan struct{}
}

// 레이트 리미터 생성 (초당 요청 수 제한)
func NewRateLimiter(requestsPerSecond int) *RateLimiter {
    rl := &RateLimiter{
        ticker:   time.NewTicker(time.Second / time.Duration(requestsPerSecond)),
        requests: make(chan struct{}, requestsPerSecond),
    }

    // 티커로 토큰 생성
    go func() {
        for range rl.ticker.C {
            select {
            case rl.requests <- struct{}{}:
            default:
            }
        }
    }()

    return rl
}

// 요청 허가 대기
func (rl *RateLimiter) Wait(ctx context.Context) error {
    select {
    case <-rl.requests:
        return nil
    case <-ctx.Done():
        return ctx.Err()
    }
}

// 정리
func (rl *RateLimiter) Stop() {
    rl.ticker.Stop()
    close(rl.requests)
}

// 지수 백오프 재시도
func retryWithExponentialBackoff(
    ctx context.Context,
    maxRetries int,
    initialDelay time.Duration,
    maxDelay time.Duration,
    fn func() error,
) error {
    var err error
    delay := initialDelay

    for i := 0; i < maxRetries; i++ {
        // 함수 실행
        err = fn()
        if err == nil {
            return nil
        }

        // 마지막 시도면 에러 반환
        if i == maxRetries-1 {
            break
        }

        // 컨텍스트 취소 확인
        select {
        case <-ctx.Done():
            return ctx.Err()
        default:
        }

        // 백오프 대기
        fmt.Printf("재시도 %d/%d: %v 후 재시도...\n", i+1, maxRetries, delay)
        select {
        case <-time.After(delay):
        case <-ctx.Done():
            return ctx.Err()
        }

        // 지수적으로 지연 시간 증가 (최대값 제한)
        delay = time.Duration(math.Min(
            float64(delay*2),
            float64(maxDelay),
        ))
    }

    return fmt.Errorf("최대 재시도 횟수 초과: %w", err)
}

// 레이트 리미팅이 적용된 HTTP 클라이언트
type RateLimitedClient struct {
    client      *http.Client
    rateLimiter *RateLimiter
}

func NewRateLimitedClient(requestsPerSecond int) *RateLimitedClient {
    return &RateLimitedClient{
        client: &http.Client{
            Timeout: 30 * time.Second,
        },
        rateLimiter: NewRateLimiter(requestsPerSecond),
    }
}

func (c *RateLimitedClient) Get(ctx context.Context, url string) (*http.Response, error) {
    // 레이트 리미터 대기
    if err := c.rateLimiter.Wait(ctx); err != nil {
        return nil, err
    }

    // 지수 백오프로 재시도
    var resp *http.Response
    err := retryWithExponentialBackoff(
        ctx,
        3,                    // 최대 3번 재시도
        1*time.Second,        // 초기 지연 1초
        10*time.Second,       // 최대 지연 10초
        func() error {
            req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
            if err != nil {
                return err
            }

            resp, err = c.client.Do(req)
            if err != nil {
                return err
            }

            // 429 (Too Many Requests) 상태면 재시도
            if resp.StatusCode == http.StatusTooManyRequests {
                resp.Body.Close()
                return fmt.Errorf("요청 제한 초과")
            }

            // 5xx 서버 에러도 재시도
            if resp.StatusCode >= 500 {
                resp.Body.Close()
                return fmt.Errorf("서버 에러: %d", resp.StatusCode)
            }

            return nil
        },
    )

    return resp, err
}

func (c *RateLimitedClient) Close() {
    c.rateLimiter.Stop()
}

func main() {
    // 초당 2개 요청으로 제한
    client := NewRateLimitedClient(2)
    defer client.Close()

    ctx := context.Background()
    urls := []string{
        "https://api.github.com/users/golang",
        "https://api.github.com/users/kubernetes",
        "https://api.github.com/users/docker",
        "https://api.github.com/users/prometheus",
        "https://api.github.com/users/grafana",
    }

    fmt.Println("레이트 리미팅 적용 요청 시작...")
    start := time.Now()

    for i, url := range urls {
        fmt.Printf("\n[%d] 요청: %s\n", i+1, url)
        
        resp, err := client.Get(ctx, url)
        if err != nil {
            fmt.Printf("❌ 실패: %v\n", err)
            continue
        }

        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()

        fmt.Printf("✅ 성공: 상태 %d, 크기 %d bytes\n", resp.StatusCode, len(body))
    }

    fmt.Printf("\n총 소요 시간: %v\n", time.Since(start))
    fmt.Println("(레이트 리미팅으로 인해 요청이 분산되었습니다)")
}

package main

import (
    "bytes"
    "context"
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

// 웹훅 페이로드
type WebhookPayload struct {
    Event     string                 `json:"event"`
    Timestamp int64                  `json:"timestamp"`
    Data      map[string]interface{} `json:"data"`
}

// 웹훅 클라이언트
type WebhookClient struct {
    client    *http.Client
    secretKey string
}

func NewWebhookClient(secretKey string) *WebhookClient {
    return &WebhookClient{
        client: &http.Client{
            Timeout: 10 * time.Second,
        },
        secretKey: secretKey,
    }
}

// HMAC 서명 생성
func (c *WebhookClient) generateSignature(payload []byte) string {
    h := hmac.New(sha256.New, []byte(c.secretKey))
    h.Write(payload)
    return hex.EncodeToString(h.Sum(nil))
}

// 웹훅 전송
func (c *WebhookClient) SendWebhook(ctx context.Context, url string, payload WebhookPayload) error {
    // 페이로드를 JSON으로 인코딩
    jsonData, err := json.Marshal(payload)
    if err != nil {
        return fmt.Errorf("JSON 인코딩 실패: %w", err)
    }

    // 서명 생성
    signature := c.generateSignature(jsonData)

    // 요청 생성
    req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return fmt.Errorf("요청 생성 실패: %w", err)
    }

    // 헤더 설정
    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("X-Webhook-Signature", signature)
    req.Header.Set("X-Webhook-Timestamp", fmt.Sprintf("%d", payload.Timestamp))

    // 재시도 로직 포함
    var resp *http.Response
    for i := 0; i < 3; i++ {
        resp, err = c.client.Do(req)
        if err == nil && resp.StatusCode == http.StatusOK {
            resp.Body.Close()
            return nil
        }

        if resp != nil {
            resp.Body.Close()
        }

        if i < 2 {
            time.Sleep(time.Duration(i+1) * time.Second)
        }
    }

    return fmt.Errorf("웹훅 전송 실패: %w", err)
}

// 웹훅 수신 핸들러
type WebhookHandler struct {
    secretKey string
}

func NewWebhookHandler(secretKey string) *WebhookHandler {
    return &WebhookHandler{
        secretKey: secretKey,
    }
}

// 서명 검증
func (h *WebhookHandler) verifySignature(payload []byte, signature string) bool {
    mac := hmac.New(sha256.New, []byte(h.secretKey))
    mac.Write(payload)
    expectedSignature := hex.EncodeToString(mac.Sum(nil))
    return hmac.Equal([]byte(signature), []byte(expectedSignature))
}

// HTTP 핸들러
func (h *WebhookHandler) HandleWebhook(w http.ResponseWriter, r *http.Request) {
    // POST 메서드만 허용
    if r.Method != http.MethodPost {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }

    // 본문 읽기
    body, err := io.ReadAll(r.Body)
    if err != nil {
        http.Error(w, "Failed to read body", http.StatusBadRequest)
        return
    }
    defer r.Body.Close()

    // 서명 검증
    signature := r.Header.Get("X-Webhook-Signature")
    if !h.verifySignature(body, signature) {
        http.Error(w, "Invalid signature", http.StatusUnauthorized)
        return
    }

    // 타임스탬프 검증 (5분 이내)
    timestamp := r.Header.Get("X-Webhook-Timestamp")
    // ... 타임스탬프 검증 로직 ...

    // 페이로드 파싱
    var payload WebhookPayload
    if err := json.Unmarshal(body, &payload); err != nil {
        http.Error(w, "Invalid JSON", http.StatusBadRequest)
        return
    }

    // 이벤트 처리
    if err := h.processEvent(payload); err != nil {
        http.Error(w, "Failed to process event", http.StatusInternalServerError)
        return
    }

    // 성공 응답
    w.WriteHeader(http.StatusOK)
    w.Write([]byte("OK"))
}

// 이벤트 처리
func (h *WebhookHandler) processEvent(payload WebhookPayload) error {
    fmt.Printf("이벤트 수신: %s\n", payload.Event)
    fmt.Printf("데이터: %+v\n", payload.Data)

    switch payload.Event {
    case "payment.completed":
        fmt.Println("결제 완료 처리")
        // 결제 완료 로직...
    case "order.created":
        fmt.Println("주문 생성 처리")
        // 주문 생성 로직...
    case "user.registered":
        fmt.Println("사용자 등록 처리")
        // 사용자 등록 로직...
    default:
        fmt.Printf("알 수 없는 이벤트: %s\n", payload.Event)
    }

    return nil
}

func main() {
    secretKey := "my-secret-key-12345"

    // 웹훅 전송 예제
    client := NewWebhookClient(secretKey)
    
    payload := WebhookPayload{
        Event:     "payment.completed",
        Timestamp: time.Now().Unix(),
        Data: map[string]interface{}{
            "order_id": "ORD-12345",
            "amount":   50000,
            "currency": "KRW",
        },
    }

    ctx := context.Background()
    err := client.SendWebhook(ctx, "https://example.com/webhook", payload)
    if err != nil {
        fmt.Println("웹훅 전송 실패:", err)
    } else {
        fmt.Println("웹훅 전송 성공!")
    }

    // 웹훅 수신 서버 예제
    handler := NewWebhookHandler(secretKey)
    http.HandleFunc("/webhook", handler.HandleWebhook)
    
    fmt.Println("웹훅 서버 시작: http://localhost:8080/webhook")
    // http.ListenAndServe(":8080", nil)
}

package main

import (
    "context"
    "fmt"
    "io"
    "log"
    "net/http"
    "net/http/httputil"
    "time"
)

// 로깅 미들웨어
type LoggingTransport struct {
    Transport http.RoundTripper
    Logger    *log.Logger
}

func (t *LoggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    start := time.Now()

    // 요청 로깅
    t.Logger.Printf("→ %s %s", req.Method, req.URL.String())

    // 요청 실행
    resp, err := t.Transport.RoundTrip(req)
    
    duration := time.Since(start)

    // 응답 로깅
    if err != nil {
        t.Logger.Printf("← 에러: %v (소요시간: %v)", err, duration)
        return nil, err
    }

    t.Logger.Printf("← %d %s (소요시간: %v)", 
        resp.StatusCode, 
        http.StatusText(resp.StatusCode),
        duration,
    )

    return resp, nil
}

// 상세 디버그 로깅
type DebugTransport struct {
    Transport http.RoundTripper
}

func (t *DebugTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    // 요청 덤프
    reqDump, err := httputil.DumpRequestOut(req, true)
    if err != nil {
        log.Printf("요청 덤프 실패: %v", err)
    } else {
        log.Printf("=== 요청 ===\n%s\n", string(reqDump))
    }

    // 요청 실행
    resp, err := t.Transport.RoundTrip(req)
    if err != nil {
        return nil, err
    }

    // 응답 덤프
    respDump, err := httputil.DumpResponse(resp, true)
    if err != nil {
        log.Printf("응답 덤프 실패: %v", err)
    } else {
        log.Printf("=== 응답 ===\n%s\n", string(respDump))
    }

    return resp, nil
}

// 메트릭 수집
type MetricsCollector struct {
    TotalRequests   int64
    SuccessRequests int64
    FailedRequests  int64
    TotalDuration   time.Duration
}

type MetricsTransport struct {
    Transport http.RoundTripper
    Metrics   *MetricsCollector
}

func (t *MetricsTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    start := time.Now()
    t.Metrics.TotalRequests++

    resp, err := t.Transport.RoundTrip(req)
    
    duration := time.Since(start)
    t.Metrics.TotalDuration += duration

    if err != nil {
        t.Metrics.FailedRequests++
        return nil, err
    }

    if resp.StatusCode >= 200 && resp.StatusCode < 300 {
        t.Metrics.SuccessRequests++
    } else {
        t.Metrics.FailedRequests++
    }

    return resp, nil
}

// 메트릭 출력
func (m *MetricsCollector) PrintStats() {
    fmt.Println("\n=== HTTP 클라이언트 통계 ===")
    fmt.Printf("총 요청 수: %d\n", m.TotalRequests)
    fmt.Printf("성공: %d\n", m.SuccessRequests)
    fmt.Printf("실패: %d\n", m.FailedRequests)
    if m.TotalRequests > 0 {
        avgDuration := m.TotalDuration / time.Duration(m.TotalRequests)
        fmt.Printf("평균 응답 시간: %v\n", avgDuration)
    }
    if m.TotalRequests > 0 {
        successRate := float64(m.SuccessRequests) / float64(m.TotalRequests) * 100
        fmt.Printf("성공률: %.2f%%\n", successRate)
    }
}

// 종합 모니터링 클라이언트
func createMonitoredClient() (*http.Client, *MetricsCollector) {
    metrics := &MetricsCollector{}
    
    transport := &MetricsTransport{
        Transport: &LoggingTransport{
            Transport: http.DefaultTransport,
            Logger:    log.Default(),
        },
        Metrics: metrics,
    }

    client := &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second,
    }

    return client, metrics
}

func main() {
    // 모니터링 클라이언트 생성
    client, metrics := createMonitoredClient()

    urls := []string{
        "https://api.github.com/users/golang",
        "https://api.github.com/users/kubernetes",
        "https://jsonplaceholder.typicode.com/posts/1",
        "https://httpbin.org/status/404", // 404 에러
        "https://httpbin.org/delay/2",    // 지연
    }

    ctx := context.Background()

    // 여러 요청 실행
    for _, url := range urls {
        req, _ := http.NewRequestWithContext(ctx, "GET", url, nil)
        resp, err := client.Do(req)
        
        if err != nil {
            log.Printf("요청 실패: %v", err)
            continue
        }

        io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
    }

    // 통계 출력
    metrics.PrintStats()
}