const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');

async function analyzeFace(imagePath, apiKey) {
    const form = new FormData();
    form.append('file', fs.createReadStream(imagePath));
    
    try {
        const response = await axios.post('http://example.hiface.app/detect-face-shape', form, {
            headers: {
                ...form.getHeaders(),
                'x-api-key': apiKey
            }
        });
        
        return response.data;
    } catch (error) {
        throw new Error(error.response?.data?.message || error.message);
    }
}

// Usage
(async () => {
    try {
        const apiKey = 'your-api-key-here';
        const result = await analyzeFace('path/to/image.jpg', apiKey);
        
        if (result.status === 'success') {
            const data = result.data;
            console.log(`Face Shape: ${data.face_shape}`);
            console.log(`Confidence: ${data.face_shape_confidence}`);
            console.log(`Age Estimate: ${data.age_estimate}`);
            console.log(`Gender: ${data.gender}`);
            console.log(`BMI Estimate: ${data.bmi_estimate}`);
        }
    } catch (error) {
        console.error('Error:', error.message);
    }
})();

# Analyze Face Image
curl -X POST http://example.hiface.app/detect-face-shape \
  -H "x-api-key: your-api-key-here" \
  -F "file=@path/to/image.jpg"

# Pretty print JSON response
curl -X POST http://example.hiface.app/detect-face-shape \
  -H "x-api-key: your-api-key-here" \
  -F "file=@path/to/image.jpg" | jq .

<?php
function analyzeFace($imagePath, $apiKey) {
    $url = 'http://example.hiface.app/detect-face-shape';
    
    $curl = curl_init();
    
    curl_setopt_array($curl, [
        CURLOPT_URL => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => [
            'x-api-key: ' . $apiKey
        ],
        CURLOPT_POSTFIELDS => [
            'file' => new CURLFile($imagePath)
        ]
    ]);
    
    $response = curl_exec($curl);
    $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    curl_close($curl);
    
    if ($httpCode !== 200) {
        throw new Exception("HTTP Error: " . $httpCode);
    }
    
    return json_decode($response, true);
}

// Usage
try {
    $apiKey = 'your-api-key-here';
    $result = analyzeFace('path/to/image.jpg', $apiKey);

    if ($result['status'] === 'success') {
        $data = $result['data'];
        echo "Face Shape: " . $data['face_shape'] . "\n";
        echo "Confidence: " . $data['face_shape_confidence'] . "\n";
        echo "Age Estimate: " . $data['age_estimate'] . "\n";
        echo "Gender: " . $data['gender'] . "\n";
    } else {
        echo "Error: " . $result['message'] . "\n";
    }
} catch (Exception $e) {
    echo "Exception: " . $e->getMessage() . "\n";
}
?>

package main

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

type FaceAnalysisResponse struct {
    Status  string `json:"status"`
    Message string `json:"message"`
    Data    struct {
        FaceShape           string  `json:"face_shape"`
        FaceShapeConfidence float64 `json:"face_shape_confidence"`
        AgeEstimate         int     `json:"age_estimate"`
        Gender              string  `json:"gender"`
        BMIEstimate         float64 `json:"bmi_estimate"`
    } `json:"data"`
}

func analyzeFace(imagePath, apiKey string) (*FaceAnalysisResponse, error) {
    file, err := os.Open(imagePath)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    var body bytes.Buffer
    writer := multipart.NewWriter(&body)
    
    part, err := writer.CreateFormFile("file", filepath.Base(imagePath))
    if err != nil {
        return nil, err
    }
    
    _, err = io.Copy(part, file)
    if err != nil {
        return nil, err
    }
    
    writer.Close()

    req, err := http.NewRequest("POST", "http://example.hiface.app/detect-face-shape", &body)
    if err != nil {
        return nil, err
    }

    req.Header.Set("Content-Type", writer.FormDataContentType())
    req.Header.Set("x-api-key", apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    var result FaceAnalysisResponse
    err = json.NewDecoder(resp.Body).Decode(&result)
    return &result, err
}

func main() {
    apiKey := "your-api-key-here"
    result, err := analyzeFace("path/to/image.jpg", apiKey)
    
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }

    if result.Status == "success" {
        fmt.Printf("Face Shape: %s\n", result.Data.FaceShape)
        fmt.Printf("Confidence: %.2f\n", result.Data.FaceShapeConfidence)
        fmt.Printf("Age Estimate: %d\n", result.Data.AgeEstimate)
        fmt.Printf("Gender: %s\n", result.Data.Gender)
    } else {
        fmt.Printf("Error: %s\n", result.Message)
    }
}

import Foundation

struct FaceAnalysisResponse: Codable {
    let status: String
    let message: String
    let data: FaceData?
    
    struct FaceData: Codable {
        let faceShape: String
        let faceShapeConfidence: Double
        let ageEstimate: Int
        let gender: String
        let bmiEstimate: Double
        
        enum CodingKeys: String, CodingKey {
            case faceShape = "face_shape"
            case faceShapeConfidence = "face_shape_confidence"
            case ageEstimate = "age_estimate"
            case gender, bmiEstimate = "bmi_estimate"
        }
    }
}

func analyzeFace(imagePath: String, apiKey: String, completion: @escaping (Result<FaceAnalysisResponse, Error>) -> Void) {
    guard let url = URL(string: "http://example.hiface.app/detect-face-shape") else {
        completion(.failure(NSError(domain: "Invalid URL", code: 0, userInfo: nil)))
        return
    }
    
    guard let imageData = NSData(contentsOfFile: imagePath) else {
        completion(.failure(NSError(domain: "File not found", code: 0, userInfo: nil)))
        return
    }
    
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue(apiKey, forHTTPHeaderField: "x-api-key")
    
    let boundary = "Boundary-\(UUID().uuidString)"
    request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
    
    var body = Data()
    body.append("--\(boundary)\r\n".data(using: .utf8)!)
    body.append("Content-Disposition: form-data; name=\"file\"; filename=\"image.jpg\"\r\n".data(using: .utf8)!)
    body.append("Content-Type: image/jpeg\r\n\r\n".data(using: .utf8)!)
    body.append(imageData as Data)
    body.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
    
    request.httpBody = body
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let data = data else {
            completion(.failure(NSError(domain: "No data", code: 0, userInfo: nil)))
            return
        }
        
        do {
            let result = try JSONDecoder().decode(FaceAnalysisResponse.self, from: data)
            completion(.success(result))
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

// Usage
analyzeFace(imagePath: "path/to/image.jpg", apiKey: "your-api-key-here") { result in
    switch result {
    case .success(let response):
        if response.status == "success", let data = response.data {
            print("Face Shape: \(data.faceShape)")
            print("Confidence: \(data.faceShapeConfidence)")
            print("Age Estimate: \(data.ageEstimate)")
            print("Gender: \(data.gender)")
        } else {
            print("Error: \(response.message)")
        }
    case .failure(let error):
        print("Error: \(error.localizedDescription)")
    }
}