package main

import (
    "github.com/samart/terraform-schema-generator/pkg/generator"
)

func main() {
    // One-liner: Generate schema from Terraform content
    schema, err := generator.FromStringQuick(`
        variable "cluster_name" {
            type        = string
            description = "ECS cluster name"
        }
    `)

    if err != nil {
        panic(err)
    }

    // schema is ready to use!
}

import "github.com/samart/terraform-schema-generator/pkg/generator"

// From a file
err := generator.New().
    FromFile("variables.tf").
    Parse().
    Convert().
    Validate().
    ToFile("schema.json").
    Error()

// From multiple sources
schema, err := generator.New().
    FromDirectory("./terraform").
    FromString("override.tf", overrides).
    Parse().
    Convert().
    ValidateAgainstMetaSchema().
    JSON()

// Quick helpers for common cases
schema, err := generator.FromDirectoryQuick("./my-terraform-module")

import (
    "github.com/samart/terraform-schema-generator/pkg/parser"
    "github.com/samart/terraform-schema-generator/pkg/converter"
)

// Parse
p := parser.NewParser()
files := map[string]io.Reader{...}
result, _ := p.ParseFiles(files)

// Convert
c := converter.NewConverter()
schema, _ := c.ConvertToJSONSchema7(result)
schemaJSON, _ := c.ToJSON(schema)

// Generate schema from terraform-aws-eks module
schema := generateSchemaFromModule("terraform-aws-eks")

// Use schema for:
// - Dynamic form generation in React/Vue
// - Input validation before submission
// - API request validation
// - Documentation generation

// In your CI/CD pipeline
func validateInfrastructureRequest(yamlPath, schemaPath string) error {
    // Load YAML
    yamlData, _ := os.ReadFile(yamlPath)
    var input map[string]interface{}
    yaml.Unmarshal(yamlData, &input)

    // Validate against schema
    schemaLoader := gojsonschema.NewReferenceLoader("file://" + schemaPath)
    inputJSON, _ := json.Marshal(input)
    documentLoader := gojsonschema.NewBytesLoader(inputJSON)

    result, _ := gojsonschema.Validate(schemaLoader, documentLoader)
    if !result.Valid() {
        return fmt.Errorf("validation failed: %v", result.Errors())
    }
    return nil
}

validator := validator.NewMetaSchemaValidator()
err := validator.ValidateAgainstMetaSchema(schemaJSON)
// Ensures spec compliance

// Platform team: Generate schema with filtered variables
schema := generateSchemaFromModule("terraform-aws-eks",
    FilterVariables("cluster_name", "vpc_id", "subnet_ids", "node_groups"))

// Developers: Use simple YAML

// Create parser
parser := parser.NewParser()

// Parse files
files := map[string]io.Reader{
    "variables.tf": reader,
}
result, err := parser.ParseFiles(files)

// Access parsed data
for _, variable := range result.Variables {
    fmt.Printf("%s: %s\n", variable.Name, variable.Type)
}

type ParseResult struct {
    Variables []Variable
    Outputs   []Output
    Resources []Resource
    Modules   []Module
    Providers []Provider
}

type Variable struct {
    Name        string
    Type        string
    Description string
    Default     interface{}
    Required    bool
    Sensitive   bool
    Nullable    bool
    Ephemeral   bool
    Validations []Validation
    Metadata    map[string]interface{}
}

// Create converter
converter := converter.NewConverter()

// Convert to JSON Schema
schema, err := converter.ConvertToJSONSchema7(parseResult)

// Export as JSON
schemaJSON, err := converter.ToJSON(schema)

type JSONSchema7 struct {
    Schema               string              `json:"$schema"`
    Type                 interface{}         `json:"type"`
    Properties           map[string]Property `json:"properties,omitempty"`
    Required             []string            `json:"required,omitempty"`
    AdditionalProperties interface{}         `json:"additionalProperties,omitempty"`
}

// Validate schema structure
validator := validator.NewValidator()
err := validator.ValidateSchema(schema)

// Validate against meta-schema
metaValidator := validator.NewMetaSchemaValidator()
err := metaValidator.ValidateAgainstMetaSchema(schemaJSON)

// API endpoint for infrastructure requests
func createInfrastructure(w http.ResponseWriter, r *http.Request) {
    var input map[string]interface{}
    json.NewDecoder(r.Body).Decode(&input)

    // Validate against schema
    moduleType := input["module_type"].(string)
    schemaPath := fmt.Sprintf("schemas/%s/schema.json", moduleType)

    if err := validateInput(input, schemaPath); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }

    // Generate Terraform files from YAML
    // Execute Terraform
    // Return results
}

// Custom converter with extensions
type CustomConverter struct {
    *converter.Converter
}

func (c *CustomConverter) MapCustomType(tfType string) interface{} {
    // Your custom logic
}

schema.Properties["cluster_name"].Examples = []interface{}{
    "dev-cluster", "prod-cluster",
}
schema.Properties["cluster_name"].Pattern = "^[a-z][a-z0-9-]*$"

// Compose schemas for VPC + EKS + RDS
compositeSchema := composeSchemas(
    vpcSchema,
    eksSchema,
    rdsSchema,
)