package main

import (
    "github.com/guillermo/gogo"
)

func main() {
    // Create a new project (NewFS is a convenience function)
    prj, _ := gogo.NewFS("./output", gogo.Options{
        InitialPackageName: "models", // Only use the first time.
        ConflictFunc:       gogo.ConflictAsk, // Allows to accept,reject or ask for each conflict
    })

    // Create a User struct
    prj.Struct(gogo.StructOpts{
        Filename: "user.go",   // Only for the first time. If the struct was moved to a different file, not a problem
        Name:     "User",
        Fields: []gogo.StructField{
            {Name: "ID", Type: "int", Annotation: "`json:\"id\"`"},
            {Name: "Name", Type: "string", Annotation: "`json:\"name\"`"},
            {Name: "Email", Type: "string", Annotation: "`json:\"email\"`"},
        },
    })

    // Add a method
    prj.Method(gogo.MethodOpts{
        Filename:     "user.go",
        Name:         "Validate",
        ReceiverType: "*User",
        ReturnType:   "error",
        Body: `if u.Email == "" {
    return errors.New("email is required")
}
return nil`,
    })
}

package models

type User struct {
	ID    int    `json:"id"`
	Name  string `json:"name"`
	Email string `json:"email"`
}

func (u *User) Validate() error {
	if u.Email == "" {
		return errors.New("email is required")
	}
	return nil
}

package models

type Customer struct {
	CustomerID int
	Name       string
	Email      string
}

func GetCustomer(id int) *Customer {
	return &Customer{CustomerID: id}
}

const MaxCustomers = 1000

package main

import (
    "github.com/guillermo/gogo"
    "github.com/guillermo/gogo/template"
)

func main() {
    // Load a reference implementation (e.g., Customer model)
    referenceFS, _ := gogo.OpenFS("./reference")
    tmpl, _ := template.New(referenceFS)

    // Transform: Customer -> User
    tmpl, _ = tmpl.RenameStruct("Customer", "User")
    tmpl, _ = tmpl.RenameStructField("User", "CustomerID", gogo.StructField{
        Name: "UserID",
        Type: "int",
    })
    tmpl, _ = tmpl.RenameFunction("GetCustomer", "GetUser")
    tmpl, _ = tmpl.RenameConstant("MaxCustomers", "MaxUsers")

    // Add new field
    tmpl, _ = tmpl.AddStructField("User", gogo.StructField{
        Name:       "CreatedAt",
        Type:       "time.Time",
        Annotation: "`json:\"created_at\"`",
    })

    // Extract and generate code
    targetFS, _ := gogo.OpenFS("./target")
    prj, _ := gogo.New(gogo.Options{FS: targetFS})

    userStruct, _ := tmpl.ExtractStruct("User")
    prj.Struct(gogo.StructOpts{
        Filename: "user.go",
        Name:     userStruct.Name,
        Fields:   userStruct.Fields,
    })
}

package models

type User struct {
	UserID    int
	Name      string
	Email     string
	CreatedAt time.Time `json:"created_at"`
}

func GetUser(id int) *User {
	return &User{UserID: id}
}

const MaxUsers = 1000

// 1. Generate initial code
prj.Struct(gogo.StructOpts{
    Filename: "user.go",
    Name:     "User",
    Fields:   []gogo.StructField{
        {Name: "ID", Type: "int"},
        {Name: "Name", Type: "string"},
    },
})

// 2. You add custom methods, move code around, edit freely
// 3. Later, add more fields - YOUR CODE STAYS INTACT
prj.Struct(gogo.StructOpts{
    Filename: "user.go",
    Name:     "User",
    Fields:   []gogo.StructField{
        {Name: "ID", Type: "int"},
        {Name: "Name", Type: "string"},
        {Name: "Email", Type: "string"}, // NEW field
    },
    PreserveExisting: true, // Your custom code is preserved!
})

// GoGo finds the User struct (even if you moved it to models.go)
// Adds only the Email field
// Keeps all your custom methods and modifications

// Reference: Fully implemented Customer model
// Transform -> Generate: User, Product, Order models
// Edit generated models freely, regenerate when schema changes

// Generate CRUD operations, repositories, handlers
// Users can customize generated code
// Regenerate when adding new features - customizations preserved

// Batch rename types, fields, functions across entire projects
// Safe to run multiple times, respects manual changes

// Keep one "golden" implementation, generate specialized versions
// Update the template, regenerate variants - custom logic preserved

// Project operations
prj.Struct(opts)      // Create/modify structs
prj.Method(opts)      // Add methods
prj.Function(opts)    // Add functions
prj.Variable(opts)    // Declare variables
prj.Constant(opts)    // Declare constants
prj.Type(opts)        // Define types

// Transformations (all return new Template)
tmpl.RenameStruct(old, new)
tmpl.RenameStructField(struct, oldField, newFieldDef)
tmpl.RenameVariable(old, new)
tmpl.RenameFunction(old, new)
tmpl.RenameConstant(old, new)
tmpl.RenameType(old, new)
tmpl.AddStructField(struct, field)
tmpl.RemoveStructField(struct, field)

// Extraction (convert to gogo types)
tmpl.ExtractStruct(name)
tmpl.ExtractFunction(name)
tmpl.ExtractMethod(receiver, name)
tmpl.ExtractVariable(name)
tmpl.ExtractConstant(name)
tmpl.ExtractType(name)

// Interactive - Ask user for each change
ConflictFunc: gogo.ConflictAsk

// Accept all changes
ConflictFunc: gogo.ConflictAccept

// Reject all changes (dry-run)
ConflictFunc: gogo.ConflictReject

// Custom handler
ConflictFunc: func(fs, old, new, info) bool {
    // Your logic here
    return shouldApply
}

// Real filesystem
fs, _ := gogo.OpenFS("./path")

// In-memory for testing
fs := gogotest.NewMemFS()
fs.WriteFile("main.go", []byte("package main"), 0644)

// Custom implementation
type CustomFS struct { /* ... */ }