repositories {
    mavenCentral()
    // Add your repository here when published
}

dependencies {
    implementation 'com.fastdfs:groovy-client:1.0.0'
}

<dependencies>
    <dependency>
        <groupId>com.fastdfs</groupId>
        <artifactId>groovy-client</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

import com.fastdfs.client.FastDFSClient
import com.fastdfs.client.config.ClientConfig

// Create client configuration
def config = new ClientConfig(
    trackerAddrs: ['192.168.1.100:22122', '192.168.1.101:22122'],
    maxConns: 100,
    connectTimeout: 5000,
    networkTimeout: 30000
)

// Initialize client
def client = new FastDFSClient(config)

try {
    // Upload a file
    def fileId = client.uploadFile('test.jpg', [:])
    println "File uploaded: ${fileId}"
    
    // Download the file
    def data = client.downloadFile(fileId)
    println "Downloaded ${data.length} bytes"
    
    // Delete the file
    client.deleteFile(fileId)
    println "File deleted"
} finally {
    // Always close the client
    client.close()
}

def data = "Hello, FastDFS!".bytes
def fileId = client.uploadBuffer(data, 'txt', [:])

def metadata = [
    'author': 'John Doe',
    'date': '2025-01-01',
    'description': 'Test file'
]
def fileId = client.uploadFile('document.pdf', metadata)

client.downloadToFile(fileId, '/path/to/save/file.jpg')

// Download bytes from offset 100, length 1024
def data = client.downloadFileRange(fileId, 100, 1024)

// Upload appender file
def fileId = client.uploadAppenderFile('log.txt', [:])

// Append data
client.appendFile(fileId, "New log entry\n".bytes)

// Modify file content
client.modifyFile(fileId, 0, "Modified content".bytes)

// Truncate file
client.truncateFile(fileId, 1024)

// Upload slave file with prefix
def slaveFileId = client.uploadSlaveFile(
    masterFileId,
    'thumb',  // prefix
    'jpg',    // extension
    thumbnailData,
    [:]
)

// Set metadata (overwrite mode)
def metadata = [
    'width': '1920',
    'height': '1080',
    'format': 'JPEG'
]
client.setMetadata(fileId, metadata, MetadataFlag.OVERWRITE)

// Set metadata (merge mode)
def additionalMetadata = [
    'color': 'RGB',
    'quality': 'high'
]
client.setMetadata(fileId, additionalMetadata, MetadataFlag.MERGE)

// Get metadata
def retrievedMetadata = client.getMetadata(fileId)
println "Metadata: ${retrievedMetadata}"

// Get file information
def fileInfo = client.getFileInfo(fileId)
println "Size: ${fileInfo.fileSize}, CRC32: ${fileInfo.crc32}"

// Check if file exists
if (client.fileExists(fileId)) {
    println "File exists"
}

def config = new ClientConfig(
    // Required: Tracker server addresses
    trackerAddrs: ['192.168.1.100:22122'],
    
    // Connection pool settings
    maxConns: 100,              // Maximum connections per server (default: 10)
    enablePool: true,           // Enable connection pooling (default: true)
    idleTimeout: 60000,         // Idle timeout in ms (default: 60000)
    
    // Timeout settings
    connectTimeout: 5000,       // Connection timeout in ms (default: 5000)
    networkTimeout: 30000,      // Network I/O timeout in ms (default: 30000)
    
    // Retry settings
    retryCount: 3,              // Number of retries (default: 3)
    retryDelayBase: 1000,       // Base retry delay in ms (default: 1000)
    retryDelayMax: 10000,       // Max retry delay in ms (default: 10000)
    
    // Advanced settings
    enableFailover: true,       // Enable automatic failover (default: true)
    enableKeepAlive: true,      // Enable TCP keep-alive (default: true)
    keepAliveInterval: 30000,   // Keep-alive interval in ms (default: 30000)
    tcpNoDelay: true,           // Disable Nagle's algorithm (default: true)
    receiveBufferSize: 65536,   // TCP receive buffer size (default: 65536)
    sendBufferSize: 65536,      // TCP send buffer size (default: 65536)
    enableLogging: false,       // Enable logging (default: false)
    logLevel: 'INFO'            // Log level: DEBUG, INFO, WARN, ERROR (default: INFO)
)

def config = new ClientConfig()
    .trackerAddrs('192.168.1.100:22122', '192.168.1.101:22122')
    .maxConns(100)
    .connectTimeout(5000)
    .networkTimeout(30000)
    .retryCount(3)

try {
    def fileId = client.uploadFile('test.jpg', [:])
} catch (FileNotFoundException e) {
    println "File not found: ${e.message}"
} catch (NoStorageServerException e) {
    println "No storage server available: ${e.message}"
} catch (ConnectionTimeoutException e) {
    println "Connection timeout: ${e.message}"
} catch (NetworkTimeoutException e) {
    println "Network timeout: ${e.message}"
} catch (InsufficientSpaceException e) {
    println "Insufficient space: ${e.message}"
} catch (FastDFSException e) {
    println "FastDFS error: ${e.message}"
} catch (Exception e) {
    println "Unexpected error: ${e.message}"
}

def client = new FastDFSClient(config)

// Use from multiple threads
def threads = (1..10).collect { threadNum ->
    Thread.start {
        try {
            def fileId = client.uploadFile("file${threadNum}.txt", [:])
            println "Thread ${threadNum} uploaded: ${fileId}"
        } catch (Exception e) {
            println "Thread ${threadNum} error: ${e.message}"
        }
    }
}

// Wait for all threads
threads*.join()

# Build the project
./gradlew build

# Run tests
./gradlew test

# Run integration tests (requires running FastDFS cluster)
./gradlew integrationTest

# Generate JAR
./gradlew jar

# Install to local Maven repository
./gradlew install

# Publish to repository
./gradlew publish

./gradlew test

./gradlew integrationTest

Upload small file (1KB):     ~2ms
Upload large file (10MB):     ~500ms
Download small file (1KB):    ~1ms
Download large file (10MB):   ~400ms
Concurrent uploads (100):     ~5s