# KeyNexus Go SDK

Official Go SDK for KeyNexus License Management System.

## Installation

```bash
go get github.com/keynexus/keynexus-go
```

## Quick Start

```go
package main

import (
    "fmt"
    "log"
    
    "github.com/keynexus/keynexus-go"
)

func main() {
    // Initialize client
    client := keynexus.NewClient(
        "app_xxxxxxxxxxxx",
        "sk_xxxxxxxxxxxxxxxxxxxx",
        nil, // uses default options
    )

    // Validate license
    result, err := client.ValidateLicense("XXXXX-XXXXX-XXXXX-XXXXX", "")
    if err != nil {
        log.Fatal(err)
    }

    if result.Success {
        fmt.Println("✅ License valid!")
        fmt.Printf("Type: %s\n", result.License.Type)
    } else {
        fmt.Printf("❌ Error: %s\n", result.Message)
    }
}
```

## Features

- ✅ Idiomatic Go code
- ✅ Full context.Context support
- ✅ Automatic HWID generation
- ✅ Thread-safe
- ✅ Zero external dependencies (uses standard library)

## Requirements

- Go 1.18 or later

## Examples

### Initialize Application

```go
result, err := client.Initialize(ctx, "1.0.0")
if err != nil {
    log.Fatal(err)
}
fmt.Println("App initialized")
```

### Validate License

```go
result, err := client.ValidateLicense(ctx, "XXXXX-XXXXX-XXXXX-XXXXX", "")
if err != nil {
    log.Fatal(err)
}

if result.Success {
    license := result.License
    if license.Type == "lifetime" {
        fmt.Println("Lifetime license")
    } else if license.DaysLeft != nil {
        fmt.Printf("Days left: %d\n", *license.DaysLeft)
    }
}
```

### Login with Password

```go
result, err := client.LoginWithPassword(ctx, "username", "password", "")
if err != nil {
    log.Fatal(err)
}

if result.Success {
    fmt.Printf("Welcome %s!\n", result.User.Username)
}
```

### Get User Info

```go
user, err := client.GetUserInfo(ctx)
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Email: %s\n", user.Email)
fmt.Printf("Subscription expires: %s\n", user.SubscriptionExpiry)
```

### With Context and Timeout

```go
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

result, err := client.ValidateLicense(ctx, licenseKey, hwid)
if err != nil {
    if errors.Is(err, context.DeadlineExceeded) {
        fmt.Println("Request timeout")
    } else {
        log.Fatal(err)
    }
}
```

## Documentation

Full documentation: https://keynexus.es/docs

API Reference: https://pkg.go.dev/github.com/keynexus/keynexus-go

## License

MIT License