go.fork.vn/core

package main

import (
    "log"
    
    "go.fork.vn/core"
    "go.fork.vn/config"
    "go.fork.vn/log"
)

func main() {
    // Tạo application instance
    app := core.New()
    
    // Lấy module loader
    loader := app.ModuleLoader()
    
    // Bootstrap application với workflow chuẩn
    if err := loader.BootstrapApplication(); err != nil {
        log.Fatal("Failed to bootstrap application:", err)
    }
    
    // Sử dụng các services
    app.Call(func(
        cfg config.Manager,
        logger log.Manager,
    ) {
        logger.Info("Application started with config", 
            "name", cfg.GetString("app.name"),
            "env", cfg.GetString("app.environment"),
        )
    })
    
    // Application sẵn sàng sử dụng
    // ...
}

type Application interface {
    // Container management
    Container() di.Container
    
    // Service Provider lifecycle
    Register(provider di.ServiceProvider)
    RegisterServiceProviders() error
    RegisterWithDependencies() error
    BootServiceProviders() error
    Boot() error
    
    // Dependency management shortcuts
    Bind(abstract string, concrete di.BindingFunc)
    Singleton(abstract string, concrete di.BindingFunc)
    Instance(abstract string, instance interface{})
    Alias(abstract, alias string)
    
    // Dependency resolution
    Make(abstract string) (interface{}, error)
    MustMake(abstract string) interface{}
    Call(callback interface{}, params ...interface{}) ([]interface{}, error)
    
    // Module loader access
    ModuleLoader() ModuleLoaderContract
}

type ModuleLoaderContract interface {
    // Bootstrap application với workflow chuẩn
    BootstrapApplication() error
    
    // Đăng ký core providers (config, log)
    RegisterCoreProviders() error
    
    // Load các modules và providers
    LoadModule(module interface{}) error
    LoadModules(modules ...interface{}) error
}

// từ go.fork.vn/di
type ServiceProvider interface {
    // Đăng ký bindings
    Register(app interface{}) error
    
    // Khởi động services
    Boot(app interface{}) error
    
    // Khai báo dependencies
    Requires() []string
    
    // Khai báo services được cung cấp
    Providers() []string
}

type MyServiceProvider struct{}

func (p *MyServiceProvider) Register(app interface{}) error {
    application, ok := app.(core.Application)
    if !ok {
        return fmt.Errorf("invalid application instance")
    }
    
    application.Singleton("my-service", func(c di.Container) interface{} {
        config := c.MustMake("config").(config.Manager)
        logger := c.MustMake("log").(log.Manager)
        
        return &MyService{
            config: config,
            logger: logger,
        }
    })
    
    return nil
}

func (p *MyServiceProvider) Boot(app interface{}) error {
    // Khởi tạo service khi cần
    return nil
}

func (p *MyServiceProvider) Requires() []string {
    return []string{"config", "log"}
}

func (p *MyServiceProvider) Providers() []string {
    return []string{"my-service"}
}

// Đăng ký multiple providers với dependencies
app := core.New()

// Đăng ký các providers
app.Register(&ConfigProvider{})
app.Register(&LogProvider{})
app.Register(&DatabaseProvider{})  // Requires: config
app.Register(&CacheProvider{})     // Requires: config
app.Register(&AuthProvider{})      // Requires: database, config
app.Register(&APIProvider{})       // Requires: auth, cache, log

// Boot application với smart dependency resolution
if err := app.Boot(); err != nil {
    log.Fatal("Failed to boot application:", err)
}

// Providers sẽ được sắp xếp và boot theo thứ tự:
// ConfigProvider → LogProvider → DatabaseProvider → CacheProvider → AuthProvider → APIProvider

app := core.New()
loader := app.ModuleLoader()

// Bootstrap core application
if err := loader.BootstrapApplication(); err != nil {
    log.Fatal("Failed to bootstrap application:", err)
}

// Load custom module sau khi app đã boot
if err := loader.LoadModule(&PaymentServiceProvider{}); err != nil {
    log.Fatal("Failed to load payment module:", err)
}

// Payment service đã sẵn sàng sử dụng
paymentService := app.MustMake("payment.service").(PaymentService)