package main

import (
	"context"
	"fmt"
	"log"

	evilmail "github.com/Evil-Mail/evilmail-go"
)

func main() {
	client := evilmail.New("your-api-key")
	ctx := context.Background()

	// Create a temporary disposable email address
	temp, err := client.TempEmail.Create(ctx, &evilmail.CreateTempEmailRequest{
		Domain:     "evilmail.pro",
		TTLMinutes: 60,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Temporary email: %s\n", temp.Email)
	fmt.Printf("Session token: %s\n", temp.SessionToken)

	// Check session status
	session, err := client.TempEmail.GetSession(ctx, temp.SessionToken)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Expires at: %s\n", session.ExpiresAt)

	// Read a specific message from temp inbox
	msg, err := client.TempEmail.GetMessage(ctx, temp.SessionToken, 1)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Subject: %s\n", msg.Subject)

	// Extract a Google verification code
	code, err := client.Verification.GetCode(ctx, evilmail.ServiceGoogle, "[email protected]")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Verification code: %s\n", code.Code)

	// List all accounts
	accounts, err := client.Accounts.List(ctx)
	if err != nil {
		log.Fatal(err)
	}
	for _, acct := range accounts {
		fmt.Printf("Account: %s\n", acct.Email)
	}

	// Batch create random email accounts
	batch, err := client.RandomEmail.BatchCreate(ctx, &evilmail.BatchCreateRandomEmailRequest{
		Domain:         "yourdomain.com",
		Count:          5,
		PasswordLength: 20,
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Created %d random accounts\n", batch.Count)
}

import "time"

// Default configuration
client := evilmail.New("your-api-key")

// Custom configuration
client := evilmail.New("your-api-key",
	evilmail.WithBaseURL("https://your-instance.example.com"),
	evilmail.WithTimeout(60 * time.Second),
	evilmail.WithHTTPClient(myCustomHTTPClient),
)

temp, err := client.TempEmail.Create(ctx, &evilmail.CreateTempEmailRequest{
	Domain:     "evilmail.pro", // optional
	TTLMinutes: 30,             // optional, minutes until auto-expiry
})

session, err := client.TempEmail.GetSession(ctx, token)

msg, err := client.TempEmail.GetMessage(ctx, token, uid)

err := client.TempEmail.Delete(ctx, token)

// List all accounts
accounts, err := client.Accounts.List(ctx)

// Create a new account
resp, err := client.Accounts.Create(ctx, &evilmail.CreateAccountRequest{
	Email:    "[email protected]",
	Password: "secure-password",
})

// Delete accounts
deleted, err := client.Accounts.Delete(ctx, &evilmail.DeleteAccountsRequest{
	Emails: []string{"[email protected]"},
})

// Change password
err = client.Accounts.ChangePassword(ctx, &evilmail.ChangePasswordRequest{
	Email:       "[email protected]",
	NewPassword: "new-secure-password",
})

// List inbox messages
messages, err := client.Inbox.List(ctx, "[email protected]")
for _, msg := range messages {
	fmt.Printf("[%d] %s: %s\n", msg.UID, msg.From, msg.Subject)
}

// Read full message content (HTML + plain text)
msg, err := client.Inbox.GetMessage(ctx, 12345, "[email protected]")
fmt.Printf("HTML: %s\nText: %s\n", msg.HTML, msg.Text)

code, err := client.Verification.GetCode(ctx, evilmail.ServiceGoogle, "[email protected]")
fmt.Printf("Code: %s (from: %s)\n", code.Code, code.From)

// Preview a random email (without creating it)
preview, err := client.RandomEmail.Preview(ctx)
fmt.Printf("%s : %s\n", preview.Email, preview.Password)

// Batch create random email accounts
batch, err := client.RandomEmail.BatchCreate(ctx, &evilmail.BatchCreateRandomEmailRequest{
	Domain:         "yourdomain.com",
	Count:          10,
	PasswordLength: 20,
})
for _, cred := range batch.Emails {
	fmt.Printf("%s : %s\n", cred.Email, cred.Password)
}

// List customer domains (authenticated)
domains, err := client.Domains.List(ctx)
fmt.Println("Free:", domains.Free)
fmt.Println("Premium:", domains.Premium)
fmt.Println("Custom:", domains.Customer)

// List public domains (unauthenticated)
public, err := client.PublicDomains.List(ctx)
fmt.Println("Domains:", public.Domains)

link, err := client.Shortlinks.Create(ctx, &evilmail.ShortlinkRequest{
	Token: sessionToken,
	Type:  "session",
})
fmt.Printf("Short URL: %s\n", link.ShortURL)

import "errors"

msg, err := client.Inbox.GetMessage(ctx, uid, email)
if err != nil {
	// Check for specific API errors
	if evilmail.IsNotFoundError(err) {
		fmt.Println("Message not found")
		return
	}
	if evilmail.IsAuthError(err) {
		fmt.Println("Invalid API key — check your credentials")
		return
	}
	if evilmail.IsRateLimitError(err) {
		fmt.Println("Rate limited — slow down and retry")
		return
	}

	// Generic API error with status code
	var apiErr *evilmail.APIError
	if errors.As(err, &apiErr) {
		fmt.Printf("API error %d: %s\n", apiErr.StatusCode, apiErr.Message)
		return
	}

	// Client-side validation error
	var valErr *evilmail.ValidationError
	if errors.As(err, &valErr) {
		fmt.Printf("Invalid parameter %s: %s\n", valErr.Field, valErr.Message)
		return
	}

	// Network or other error
	log.Fatal(err)
}

// With timeout
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
messages, err := client.Inbox.List(ctx, "[email protected]")

// With cancellation
ctx, cancel := context.WithCancel(context.Background())
go func() {
	<-sigChan
	cancel()
}()
temp, err := client.TempEmail.Create(ctx, nil)