package main

import (
        "context"
        "flag"
        "fmt"
        "net/http"
        "os"
        "os/signal"
        "path"
        "strconv"
        "strings"
        "syscall"

        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/logging"
        "git.defalsify.org/vise.git/resource"

        "git.grassecon.net/urdt/ussd/internal/handlers"
        httpserver "git.grassecon.net/urdt/ussd/internal/http"
        "git.grassecon.net/urdt/ussd/internal/storage"
)

var (
        logg      = logging.NewVanilla()
        scriptDir = path.Join("services", "registration")
)

type atRequestParser struct{}

func (arp *atRequestParser) GetSessionId(rq any) (string, error) {
        rqv, ok := rq.(*http.Request)
        if !ok {
                return "", handlers.ErrInvalidRequest
        }
        if err := rqv.ParseForm(); err != nil {
                return "", fmt.Errorf("failed to parse form data: %v", err)
        }

        phoneNumber := rqv.FormValue("phoneNumber")
        if phoneNumber == "" {
                return "", fmt.Errorf("no phone number found")
        }

        return phoneNumber, nil
}

func (arp *atRequestParser) GetInput(rq any) ([]byte, error) {
        rqv, ok := rq.(*http.Request)
        if !ok {
                return nil, handlers.ErrInvalidRequest
        }
        if err := rqv.ParseForm(); err != nil {
                return nil, fmt.Errorf("failed to parse form data: %v", err)
        }

        text := rqv.FormValue("text")

        parts := strings.Split(text, "*")
        if len(parts) == 0 {
                return nil, fmt.Errorf("no input found")
        }

        return []byte(parts[len(parts)-1]), nil
}

func main() {
        var dbDir string
        var resourceDir string
        var size uint
        var engineDebug bool
        var host string
        var port uint
        flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
        flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
        flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
        flag.UintVar(&size, "s", 160, "max size of output")
        flag.StringVar(&host, "h", "127.0.0.1", "http host")
        flag.UintVar(&port, "p", 7123, "http port")
        flag.Parse()

        logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size)

        ctx := context.Background()
        pfp := path.Join(scriptDir, "pp.csv")

        cfg := engine.Config{
                Root:       "root",
                OutputSize: uint32(size),
                FlagCount:  uint32(20),
        }

        if engineDebug {
                cfg.EngineDebug = true
        }

        menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
        rs, err := menuStorageService.GetResource(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        err = menuStorageService.EnsureDbDir()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        userdataStore, err := menuStorageService.GetUserdataDb(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }
        defer userdataStore.Close()

        dbResource, ok := rs.(*resource.DbResource)
        if !ok {
                os.Exit(1)
        }

        lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
        lhs.SetDataStore(&userdataStore)

        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        hl, err := lhs.GetHandler()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        stateStore, err := menuStorageService.GetStateStore(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }
        defer stateStore.Close()

        rp := &atRequestParser{}
        bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
        sh := httpserver.NewATSessionHandler(bsh)
        s := &http.Server{
                Addr:    fmt.Sprintf("%s:%s", host, strconv.Itoa(int(port))),
                Handler: sh,
        }
        s.RegisterOnShutdown(sh.Shutdown)

        cint := make(chan os.Signal)
        cterm := make(chan os.Signal)
        signal.Notify(cint, os.Interrupt, syscall.SIGINT)
        signal.Notify(cterm, os.Interrupt, syscall.SIGTERM)
        go func() {
                select {
                case _ = <-cint:
                case _ = <-cterm:
                }
                s.Shutdown(ctx)
        }()
        err = s.ListenAndServe()
        if err != nil {
                logg.Infof("Server closed with error", "err", err)
        }
}

package main

import (
        "context"
        "flag"
        "fmt"
        "os"
        "os/signal"
        "path"
        "syscall"

        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/logging"
        "git.defalsify.org/vise.git/resource"

        "git.grassecon.net/urdt/ussd/internal/handlers"
        "git.grassecon.net/urdt/ussd/internal/storage"
)

var (
        logg      = logging.NewVanilla()
        scriptDir = path.Join("services", "registration")
)

type asyncRequestParser struct {
        sessionId string
        input     []byte
}

func (p *asyncRequestParser) GetSessionId(r any) (string, error) {
        return p.sessionId, nil
}

func (p *asyncRequestParser) GetInput(r any) ([]byte, error) {
        return p.input, nil
}

func main() {
        var sessionId string
        var dbDir string
        var resourceDir string
        var size uint
        var engineDebug bool
        var host string
        var port uint
        flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
        flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
        flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
        flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
        flag.UintVar(&size, "s", 160, "max size of output")
        flag.StringVar(&host, "h", "127.0.0.1", "http host")
        flag.UintVar(&port, "p", 7123, "http port")
        flag.Parse()

        logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size, "sessionId", sessionId)

        ctx := context.Background()
        pfp := path.Join(scriptDir, "pp.csv")

        cfg := engine.Config{
                Root:       "root",
                OutputSize: uint32(size),
                FlagCount:  uint32(16),
        }

        if engineDebug {
                cfg.EngineDebug = true
        }

        menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
        rs, err := menuStorageService.GetResource(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        err = menuStorageService.EnsureDbDir()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        userdataStore, err := menuStorageService.GetUserdataDb(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }
        defer userdataStore.Close()

        dbResource, ok := rs.(*resource.DbResource)
        if !ok {
                os.Exit(1)
        }

        lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
        lhs.SetDataStore(&userdataStore)

        hl, err := lhs.GetHandler()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        stateStore, err := menuStorageService.GetStateStore(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }
        defer stateStore.Close()

        rp := &asyncRequestParser{
                sessionId: sessionId,
        }
        sh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
        cfg.SessionId = sessionId
        rqs := handlers.RequestSession{
                Ctx:    ctx,
                Writer: os.Stdout,
                Config: cfg,
        }

        cint := make(chan os.Signal)
        cterm := make(chan os.Signal)
        signal.Notify(cint, os.Interrupt, syscall.SIGINT)
        signal.Notify(cterm, os.Interrupt, syscall.SIGTERM)
        go func() {
                select {
                case _ = <-cint:
                case _ = <-cterm:
                }
                sh.Shutdown()
        }()

        for true {
                rqs, err = sh.Process(rqs)
                if err != nil {
                        logg.ErrorCtxf(ctx, "error in process: %v", "err", err)
                        fmt.Errorf("error in process: %v", err)
                        os.Exit(1)
                }
                rqs, err = sh.Output(rqs)
                if err != nil {
                        logg.ErrorCtxf(ctx, "error in output: %v", "err", err)
                        fmt.Errorf("error in output: %v", err)
                        os.Exit(1)
                }
                rqs, err = sh.Reset(rqs)
                if err != nil {
                        logg.ErrorCtxf(ctx, "error in reset: %v", "err", err)
                        fmt.Errorf("error in reset: %v", err)
                        os.Exit(1)
                }
                fmt.Println("")
                _, err = fmt.Scanln(&rqs.Input)
                if err != nil {
                        logg.ErrorCtxf(ctx, "error in input", "err", err)
                        fmt.Errorf("error in input: %v", err)
                        os.Exit(1)
                }
        }
}

package main

import (
        "context"
        "flag"
        "fmt"
        "net/http"
        "os"
        "os/signal"
        "path"
        "strconv"
        "syscall"

        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/logging"
        "git.defalsify.org/vise.git/resource"

        "git.grassecon.net/urdt/ussd/internal/handlers"
        httpserver "git.grassecon.net/urdt/ussd/internal/http"
        "git.grassecon.net/urdt/ussd/internal/storage"
)

var (
        logg      = logging.NewVanilla()
        scriptDir = path.Join("services", "registration")
)

func main() {
        var dbDir string
        var resourceDir string
        var size uint
        var engineDebug bool
        var host string
        var port uint
        flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
        flag.StringVar(&resourceDir, "resourcedir", path.Join("services", "registration"), "resource dir")
        flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
        flag.UintVar(&size, "s", 160, "max size of output")
        flag.StringVar(&host, "h", "127.0.0.1", "http host")
        flag.UintVar(&port, "p", 7123, "http port")
        flag.Parse()

        logg.Infof("start command", "dbdir", dbDir, "resourcedir", resourceDir, "outputsize", size)

        ctx := context.Background()
        pfp := path.Join(scriptDir, "pp.csv")

        cfg := engine.Config{
                Root:       "root",
                OutputSize: uint32(size),
                FlagCount:  uint32(16),
        }

        if engineDebug {
                cfg.EngineDebug = true
        }

        menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)
        rs, err := menuStorageService.GetResource(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        err = menuStorageService.EnsureDbDir()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        userdataStore, err := menuStorageService.GetUserdataDb(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }
        defer userdataStore.Close()

        dbResource, ok := rs.(*resource.DbResource)
        if !ok {
                os.Exit(1)
        }

        lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
        lhs.SetDataStore(&userdataStore)

        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        hl, err := lhs.GetHandler()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        stateStore, err := menuStorageService.GetStateStore(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }
        defer stateStore.Close()

        rp := &httpserver.DefaultRequestParser{}
        bsh := handlers.NewBaseSessionHandler(cfg, rs, stateStore, userdataStore, rp, hl)
        sh := httpserver.ToSessionHandler(bsh)
        s := &http.Server{
                Addr:    fmt.Sprintf("%s:%s", host, strconv.Itoa(int(port))),
                Handler: sh,
        }
        s.RegisterOnShutdown(sh.Shutdown)

        cint := make(chan os.Signal)
        cterm := make(chan os.Signal)
        signal.Notify(cint, os.Interrupt, syscall.SIGINT)
        signal.Notify(cterm, os.Interrupt, syscall.SIGTERM)
        go func() {
                select {
                case _ = <-cint:
                case _ = <-cterm:
                }
                s.Shutdown(ctx)
        }()
        err = s.ListenAndServe()
        if err != nil {
                logg.Infof("Server closed with error", "err", err)
        }
}

package main

import (
        "context"
        "flag"
        "fmt"
        "os"
        "path"

        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/logging"
        "git.defalsify.org/vise.git/resource"
        "git.grassecon.net/urdt/ussd/internal/handlers"
        "git.grassecon.net/urdt/ussd/internal/storage"
)

var (
        logg      = logging.NewVanilla()
        scriptDir = path.Join("services", "registration")
)

func main() {
        var dbDir string
        var size uint
        var sessionId string
        var engineDebug bool
        flag.StringVar(&sessionId, "session-id", "075xx2123", "session id")
        flag.StringVar(&dbDir, "dbdir", ".state", "database dir to read from")
        flag.BoolVar(&engineDebug, "d", false, "use engine debug output")
        flag.UintVar(&size, "s", 160, "max size of output")
        flag.Parse()

        logg.Infof("start command", "dbdir", dbDir, "outputsize", size)

        ctx := context.Background()
        ctx = context.WithValue(ctx, "SessionId", sessionId)
        pfp := path.Join(scriptDir, "pp.csv")

        cfg := engine.Config{
                Root:       "root",
                SessionId:  sessionId,
                OutputSize: uint32(size),
                FlagCount:  uint32(20),
        }

        resourceDir := scriptDir
        menuStorageService := storage.NewMenuStorageService(dbDir, resourceDir)

        err := menuStorageService.EnsureDbDir()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        rs, err := menuStorageService.GetResource(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        pe, err := menuStorageService.GetPersister(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        userdatastore, err := menuStorageService.GetUserdataDb(ctx)
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        dbResource, ok := rs.(*resource.DbResource)
        if !ok {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        lhs, err := handlers.NewLocalHandlerService(pfp, true, dbResource, cfg, rs)
        lhs.SetDataStore(&userdatastore)
        lhs.SetPersister(pe)

        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        hl, err := lhs.GetHandler()
        if err != nil {
                fmt.Fprintf(os.Stderr, err.Error())
                os.Exit(1)
        }

        en := lhs.GetEngine()
        en = en.WithFirst(hl.Init)
        if engineDebug {
                en = en.WithDebug(nil)
        }

        err = engine.Loop(ctx, en, os.Stdin, os.Stdout, nil)
        if err != nil {
                fmt.Fprintf(os.Stderr, "loop exited with error: %v\n", err)
                os.Exit(1)
        }
}

package handlers

import (
        "git.defalsify.org/vise.git/db"
        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/persist"
        "git.defalsify.org/vise.git/resource"

        "git.grassecon.net/urdt/ussd/internal/handlers/ussd"
        "git.grassecon.net/urdt/ussd/internal/storage"
)

type BaseSessionHandler struct {
        cfgTemplate engine.Config
        rp RequestParser
        rs resource.Resource
        hn *ussd.Handlers
        provider storage.StorageProvider
}

func NewBaseSessionHandler(cfg engine.Config, rs resource.Resource, stateDb db.Db, userdataDb db.Db, rp RequestParser, hn *ussd.Handlers) *BaseSessionHandler {
        return &BaseSessionHandler{
                cfgTemplate: cfg,
                rs: rs,
                hn: hn,
                rp: rp,
                provider: storage.NewSimpleStorageProvider(stateDb, userdataDb),
        }
}

func(f* BaseSessionHandler) Shutdown() {
        err := f.provider.Close()
        if err != nil {
                logg.Errorf("handler shutdown error", "err", err)
        }
}

func(f *BaseSessionHandler) GetEngine(cfg engine.Config, rs resource.Resource, pr *persist.Persister) engine.Engine {
        en := engine.NewEngine(cfg, rs)
        en = en.WithPersister(pr)
        return en
}

func(f *BaseSessionHandler) Process(rqs RequestSession) (RequestSession, error) {
        var r bool
        var err error
        var ok bool
        
        logg.InfoCtxf(rqs.Ctx, "new request", "data", rqs)

        rqs.Storage, err = f.provider.Get(rqs.Config.SessionId)
        if err != nil {
                logg.ErrorCtxf(rqs.Ctx, "", "storage get error", err)
                return rqs, ErrStorage
        }

        f.hn = f.hn.WithPersister(rqs.Storage.Persister)
        eni := f.GetEngine(rqs.Config, f.rs, rqs.Storage.Persister)
        en, ok := eni.(*engine.DefaultEngine)
        if !ok {
                perr := f.provider.Put(rqs.Config.SessionId, rqs.Storage)
                rqs.Storage = nil
                if perr != nil {
                        logg.ErrorCtxf(rqs.Ctx, "", "storage put error", perr)
                }
                return rqs, ErrEngineType
        }
        en = en.WithFirst(f.hn.Init)
        if rqs.Config.EngineDebug {
                en = en.WithDebug(nil)
        }
        rqs.Engine = en

        r, err = rqs.Engine.Exec(rqs.Ctx, rqs.Input)
        if err != nil {
                perr := f.provider.Put(rqs.Config.SessionId, rqs.Storage)
                rqs.Storage = nil
                if perr != nil {
                        logg.ErrorCtxf(rqs.Ctx, "", "storage put error", perr)
                }
                return rqs, err
        }

        rqs.Continue = r 
        return rqs, nil
}

func(f *BaseSessionHandler) Output(rqs RequestSession) (RequestSession,  error) {
        var err error
        _, err = rqs.Engine.Flush(rqs.Ctx, rqs.Writer)
        return rqs, err
}

func(f *BaseSessionHandler) Reset(rqs RequestSession) (RequestSession, error) {
        defer f.provider.Put(rqs.Config.SessionId, rqs.Storage)
        return rqs, rqs.Engine.Finish()
}

func(f *BaseSessionHandler) GetConfig() engine.Config {
        return f.cfgTemplate
}

func(f *BaseSessionHandler) GetRequestParser() RequestParser {
        return f.rp
}

package handlers

import (
        "git.defalsify.org/vise.git/asm"
        "git.defalsify.org/vise.git/db"
        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/persist"
        "git.defalsify.org/vise.git/resource"
        "git.grassecon.net/urdt/ussd/internal/handlers/ussd"
)

type HandlerService interface {
        GetHandler() (*ussd.Handlers, error)
}

func getParser(fp string, debug bool) (*asm.FlagParser, error) {
        flagParser := asm.NewFlagParser().WithDebug()
        _, err := flagParser.Load(fp)
        if err != nil {
                return nil, err
        }
        return flagParser, nil
}

type LocalHandlerService struct {
        Parser        *asm.FlagParser
        DbRs          *resource.DbResource
        Pe            *persist.Persister
        UserdataStore *db.Db
        Cfg           engine.Config
        Rs            resource.Resource
}

func NewLocalHandlerService(fp string, debug bool, dbResource *resource.DbResource, cfg engine.Config, rs resource.Resource) (*LocalHandlerService, error) {
        parser, err := getParser(fp, debug)
        if err != nil {
                return nil, err
        }
        return &LocalHandlerService{
                Parser: parser,
                DbRs:   dbResource,
                Cfg:    cfg,
                Rs:     rs,
        }, nil
}

func (ls *LocalHandlerService) SetPersister(Pe *persist.Persister) {
        ls.Pe = Pe
}

func (ls *LocalHandlerService) SetDataStore(db *db.Db) {
        ls.UserdataStore = db
}

func (ls *LocalHandlerService) GetHandler() (*ussd.Handlers, error) {
        ussdHandlers, err := ussd.NewHandlers(ls.Parser, *ls.UserdataStore)
        if err != nil {
                return nil, err
        }
        ussdHandlers = ussdHandlers.WithPersister(ls.Pe)
        ls.DbRs.AddLocalFunc("set_language", ussdHandlers.SetLanguage)
        ls.DbRs.AddLocalFunc("create_account", ussdHandlers.CreateAccount)
        ls.DbRs.AddLocalFunc("save_pin", ussdHandlers.SavePin)
        ls.DbRs.AddLocalFunc("verify_pin", ussdHandlers.VerifyPin)
        ls.DbRs.AddLocalFunc("check_identifier", ussdHandlers.CheckIdentifier)
        ls.DbRs.AddLocalFunc("check_account_status", ussdHandlers.CheckAccountStatus)
        ls.DbRs.AddLocalFunc("authorize_account", ussdHandlers.Authorize)
        ls.DbRs.AddLocalFunc("quit", ussdHandlers.Quit)
        ls.DbRs.AddLocalFunc("check_balance", ussdHandlers.CheckBalance)
        ls.DbRs.AddLocalFunc("validate_recipient", ussdHandlers.ValidateRecipient)
        ls.DbRs.AddLocalFunc("transaction_reset", ussdHandlers.TransactionReset)
        ls.DbRs.AddLocalFunc("max_amount", ussdHandlers.MaxAmount)
        ls.DbRs.AddLocalFunc("validate_amount", ussdHandlers.ValidateAmount)
        ls.DbRs.AddLocalFunc("reset_transaction_amount", ussdHandlers.ResetTransactionAmount)
        ls.DbRs.AddLocalFunc("get_recipient", ussdHandlers.GetRecipient)
        ls.DbRs.AddLocalFunc("get_sender", ussdHandlers.GetSender)
        ls.DbRs.AddLocalFunc("get_amount", ussdHandlers.GetAmount)
        ls.DbRs.AddLocalFunc("reset_incorrect", ussdHandlers.ResetIncorrectPin)
        ls.DbRs.AddLocalFunc("save_firstname", ussdHandlers.SaveFirstname)
        ls.DbRs.AddLocalFunc("save_familyname", ussdHandlers.SaveFamilyname)
        ls.DbRs.AddLocalFunc("save_gender", ussdHandlers.SaveGender)
        ls.DbRs.AddLocalFunc("save_location", ussdHandlers.SaveLocation)
        ls.DbRs.AddLocalFunc("save_yob", ussdHandlers.SaveYob)
        ls.DbRs.AddLocalFunc("save_offerings", ussdHandlers.SaveOfferings)
        ls.DbRs.AddLocalFunc("quit_with_balance", ussdHandlers.QuitWithBalance)
        ls.DbRs.AddLocalFunc("reset_account_authorized", ussdHandlers.ResetAccountAuthorized)
        ls.DbRs.AddLocalFunc("reset_allow_update", ussdHandlers.ResetAllowUpdate)
        ls.DbRs.AddLocalFunc("get_profile_info", ussdHandlers.GetProfileInfo)
        ls.DbRs.AddLocalFunc("verify_yob", ussdHandlers.VerifyYob)
        ls.DbRs.AddLocalFunc("reset_incorrect_date_format", ussdHandlers.ResetIncorrectYob)
        ls.DbRs.AddLocalFunc("initiate_transaction", ussdHandlers.InitiateTransaction)
        ls.DbRs.AddLocalFunc("save_temporary_pin", ussdHandlers.SaveTemporaryPin)
        ls.DbRs.AddLocalFunc("verify_new_pin", ussdHandlers.VerifyNewPin)
        ls.DbRs.AddLocalFunc("confirm_pin_change", ussdHandlers.ConfirmPinChange)
        ls.DbRs.AddLocalFunc("quit_with_help", ussdHandlers.QuitWithHelp)
        ls.DbRs.AddLocalFunc("fetch_custodial_balances", ussdHandlers.FetchCustodialBalances)

        return ussdHandlers, nil
}

// TODO: enable setting of sessionId on engine init time
func (ls *LocalHandlerService) GetEngine() *engine.DefaultEngine {
        en := engine.NewEngine(ls.Cfg, ls.Rs)
        en = en.WithPersister(ls.Pe)
        return en
}

package server

import (
        "encoding/json"
        "io"
        "net/http"

        "git.grassecon.net/urdt/ussd/config"
        "git.grassecon.net/urdt/ussd/internal/models"
)

type AccountServiceInterface interface {
        CheckBalance(publicKey string) (*models.BalanceResponse, error)
        CreateAccount() (*models.AccountResponse, error)
        CheckAccountStatus(trackingId string) (*models.TrackStatusResponse, error)
}

type AccountService struct {
}

// CheckAccountStatus retrieves the status of an account transaction based on the provided tracking ID.
//
// Parameters:
//   - trackingId: A unique identifier for the account.This should be obtained from a previous call to
//     CreateAccount or a similar function that returns an AccountResponse. The `trackingId` field in the
//     AccountResponse struct can be used here to check the account status during a transaction.
//
// Returns:
//   - string: The status of the transaction as a string. If there is an error during the request or processing, this will be an empty string.
//   - error: An error if any occurred during the HTTP request, reading the response, or unmarshalling the JSON data.
//     If no error occurs, this will be nil.
func (as *AccountService) CheckAccountStatus(trackingId string) (*models.TrackStatusResponse, error) {
        resp, err := http.Get(config.TrackStatusURL + trackingId)
        if err != nil {
                return nil, err
        }
        defer resp.Body.Close()

        body, err := io.ReadAll(resp.Body)
        if err != nil {
                return nil, err
        }

        var trackResp models.TrackStatusResponse
        err = json.Unmarshal(body, &trackResp)
        if err != nil {
                return nil, err
        }

        //        status := trackResp.Result.Transaction.Status

        return &trackResp, nil
}

// CheckBalance retrieves the balance for a given public key from the custodial balance API endpoint.
// Parameters:
//   - publicKey: The public key associated with the account whose balance needs to be checked.
func (as *AccountService) CheckBalance(publicKey string) (*models.BalanceResponse, error) {

        resp, err := http.Get(config.BalanceURL + publicKey)
        if err != nil {
                return nil, err
        }
        defer resp.Body.Close()

        body, err := io.ReadAll(resp.Body)
        if err != nil {
                return nil, err
        }

        var balanceResp models.BalanceResponse
        err = json.Unmarshal(body, &balanceResp)
        if err != nil {
                return nil, err
        }

        //balance := balanceResp.Result.Balance
        return &balanceResp, nil
}

// CreateAccount creates a new account in the custodial system.
// Returns:
//   - *models.AccountResponse: A pointer to an AccountResponse struct containing the details of the created account.
//     If there is an error during the request or processing, this will be nil.
//   - error: An error if any occurred during the HTTP request, reading the response, or unmarshalling the JSON data.
//     If no error occurs, this will be nil.
func (as *AccountService) CreateAccount() (*models.AccountResponse, error) {
        resp, err := http.Post(config.CreateAccountURL, "application/json", nil)
        if err != nil {
                return nil, err
        }
        defer resp.Body.Close()

        body, err := io.ReadAll(resp.Body)
        if err != nil {
                return nil, err
        }

        var accountResp models.AccountResponse
        err = json.Unmarshal(body, &accountResp)
        if err != nil {
                return nil, err
        }

        return &accountResp, nil
}

package ussd

import (
        "bytes"
        "context"
        "fmt"
        "path"
        "regexp"
        "strconv"
        "strings"

        "git.defalsify.org/vise.git/asm"

        "git.defalsify.org/vise.git/cache"
        "git.defalsify.org/vise.git/db"
        "git.defalsify.org/vise.git/lang"
        "git.defalsify.org/vise.git/logging"
        "git.defalsify.org/vise.git/persist"
        "git.defalsify.org/vise.git/resource"
        "git.defalsify.org/vise.git/state"
        "git.grassecon.net/urdt/ussd/internal/handlers/server"
        "git.grassecon.net/urdt/ussd/internal/utils"
        "gopkg.in/leonelquinteros/gotext.v1"
)

var (
        logg           = logging.NewVanilla().WithDomain("ussdmenuhandler")
        scriptDir      = path.Join("services", "registration")
        translationDir = path.Join(scriptDir, "locale")
)

// FlagManager handles centralized flag management
type FlagManager struct {
        parser *asm.FlagParser
}

// NewFlagManager creates a new FlagManager instance
func NewFlagManager(csvPath string) (*FlagManager, error) {
        parser := asm.NewFlagParser()
        _, err := parser.Load(csvPath)
        if err != nil {
                return nil, fmt.Errorf("failed to load flag parser: %v", err)
        }

        return &FlagManager{
                parser: parser,
        }, nil
}

// GetFlag retrieves a flag value by its label
func (fm *FlagManager) GetFlag(label string) (uint32, error) {
        return fm.parser.GetFlag(label)
}

type Handlers struct {
        pe             *persist.Persister
        st             *state.State
        ca             cache.Memory
        userdataStore  utils.DataStore
        flagManager    *asm.FlagParser
        accountService server.AccountServiceInterface
}

func NewHandlers(appFlags *asm.FlagParser, userdataStore db.Db) (*Handlers, error) {
        if userdataStore == nil {
                return nil, fmt.Errorf("cannot create handler with nil userdata store")
        }
        userDb := &utils.UserDataStore{
                Db: userdataStore,
        }
        h := &Handlers{
                userdataStore:  userDb,
                flagManager:    appFlags,
                accountService: &server.AccountService{},
        }
        return h, nil
}

// Define the regex pattern as a constant
const pinPattern = `^\d{4}$`

// isValidPIN checks whether the given input is a 4 digit number
func isValidPIN(pin string) bool {
        match, _ := regexp.MatchString(pinPattern, pin)
        return match
}

func (h *Handlers) WithPersister(pe *persist.Persister) *Handlers {
        if h.pe != nil {
                panic("persister already set")
        }
        h.pe = pe
        return h
}

func (h *Handlers) Init(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var r resource.Result

        if h.pe == nil {
                logg.WarnCtxf(ctx, "handler init called before it is ready or more than once", "state", h.st, "cache", h.ca)
                return r, nil
        }
        h.st = h.pe.GetState()
        h.ca = h.pe.GetMemory()
        if h.st == nil || h.ca == nil {
                logg.ErrorCtxf(ctx, "perister fail in handler", "state", h.st, "cache", h.ca)
                return r, fmt.Errorf("cannot get state and memory for handler")
        }
        h.pe = nil

        logg.DebugCtxf(ctx, "handler has been initialized", "state", h.st, "cache", h.ca)

        return r, nil
}

// SetLanguage sets the language across the menu
func (h *Handlers) SetLanguage(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        symbol, _ := h.st.Where()
        code := strings.Split(symbol, "_")[1]

        if !utils.IsValidISO639(code) {
                return res, nil
        }
        res.FlagSet = append(res.FlagSet, state.FLAG_LANG)
        res.Content = code

        languageSetFlag, err := h.flagManager.GetFlag("flag_language_set")
        if err != nil {
                return res, err
        }
        res.FlagSet = append(res.FlagSet, languageSetFlag)

        return res, nil
}

func (h *Handlers) createAccountNoExist(ctx context.Context, sessionId string, res *resource.Result) error {
        accountResp, err := h.accountService.CreateAccount()
        data := map[utils.DataTyp]string{
                utils.DATA_TRACKING_ID:  accountResp.Result.TrackingId,
                utils.DATA_PUBLIC_KEY:   accountResp.Result.PublicKey,
                utils.DATA_CUSTODIAL_ID: accountResp.Result.CustodialId.String(),
        }

        for key, value := range data {
                store := h.userdataStore
                err := store.WriteEntry(ctx, sessionId, key, []byte(value))
                if err != nil {
                        return err
                }
        }
        flag_account_created, _ := h.flagManager.GetFlag("flag_account_created")
        res.FlagSet = append(res.FlagSet, flag_account_created)
        return err

}

// CreateAccount checks if any account exists on the JSON data file, and if not
// creates an account on the API,
// sets the default values and flags
func (h *Handlers) CreateAccount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        store := h.userdataStore
        _, err = store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_CREATED)
        if err != nil {
                if db.IsNotFound(err) {
                        logg.Printf(logging.LVL_INFO, "Creating an account because it doesn't exist")
                        err = h.createAccountNoExist(ctx, sessionId, &res)
                        if err != nil {
                                return res, err
                        }
                }
        }
        return res, nil
}

// SavePin persists the user's PIN choice into the filesystem
func (h *Handlers) SavePin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")

        accountPIN := string(input)
        // Validate that the PIN is a 4-digit number
        if !isValidPIN(accountPIN) {
                res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
                return res, nil
        }

        res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
        store := h.userdataStore
        err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN, []byte(accountPIN))
        if err != nil {
                return res, err
        }
        return res, nil
}

func (h *Handlers) VerifyNewPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        res := resource.Result{}
        _, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        flag_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
        pinInput := string(input)
        // Validate that the PIN is a 4-digit number
        if isValidPIN(pinInput) {
                res.FlagSet = append(res.FlagSet, flag_valid_pin)
        } else {
                res.FlagReset = append(res.FlagReset, flag_valid_pin)
        }

        return res, nil
}

func (h *Handlers) SaveTemporaryPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")

        accountPIN := string(input)

        // Validate that the PIN is a 4-digit number
        if !isValidPIN(accountPIN) {
                res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
                return res, nil
        }
        store := h.userdataStore
        err = store.WriteEntry(ctx, sessionId, utils.DATA_TEMPORARY_PIN, []byte(accountPIN))
        if err != nil {
                return res, err
        }
        return res, nil
}

func (h *Handlers) ConfirmPinChange(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")

        store := h.userdataStore
        temporaryPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_TEMPORARY_PIN)
        if err != nil {
                return res, err
        }
        if bytes.Equal(temporaryPin, input) {
                res.FlagReset = append(res.FlagReset, flag_pin_mismatch)
        } else {
                res.FlagSet = append(res.FlagSet, flag_pin_mismatch)
        }
        err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN, []byte(temporaryPin))
        if err != nil {
                return res, err
        }
        return res, nil
}

// VerifyPin checks whether the confirmation PIN is similar to the account PIN
// If similar, it sets the USERFLAG_PIN_SET flag allowing the user
// to access the main menu
func (h *Handlers) VerifyPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_valid_pin, _ := h.flagManager.GetFlag("flag_valid_pin")
        flag_pin_mismatch, _ := h.flagManager.GetFlag("flag_pin_mismatch")
        flag_pin_set, _ := h.flagManager.GetFlag("flag_pin_set")

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        store := h.userdataStore
        AccountPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN)
        if err != nil {
                return res, err
        }

        if bytes.Equal(input, AccountPin) {
                res.FlagSet = []uint32{flag_valid_pin}
                res.FlagReset = []uint32{flag_pin_mismatch}
                res.FlagSet = append(res.FlagSet, flag_pin_set)
        } else {
                res.FlagSet = []uint32{flag_pin_mismatch}
        }

        return res, nil
}

// codeFromCtx retrieves language codes from the context that can be used for handling translations
func codeFromCtx(ctx context.Context) string {
        var code string
        if ctx.Value("Language") != nil {
                lang := ctx.Value("Language").(lang.Language)
                code = lang.Code
        }
        return code
}

// SaveFirstname updates the first name in the gdbm with the provided input.
func (h *Handlers) SaveFirstname(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        if len(input) > 0 {
                firstName := string(input)
                store := h.userdataStore
                err = store.WriteEntry(ctx, sessionId, utils.DATA_FIRST_NAME, []byte(firstName))
                if err != nil {
                        return res, err
                }
        }

        return res, nil
}

// SaveFamilyname updates the family name in the gdbm with the provided input.
func (h *Handlers) SaveFamilyname(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        if len(input) > 0 {
                familyName := string(input)
                store := h.userdataStore
                err = store.WriteEntry(ctx, sessionId, utils.DATA_FAMILY_NAME, []byte(familyName))
                if err != nil {
                        return res, err
                }
        } else {
                return res, fmt.Errorf("a family name cannot be less than one character")
        }

        return res, nil
}

// SaveYOB updates the Year of Birth(YOB) in the gdbm with the provided input.
func (h *Handlers) SaveYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        if len(input) == 4 {
                yob := string(input)
                store := h.userdataStore
                err = store.WriteEntry(ctx, sessionId, utils.DATA_YOB, []byte(yob))
                if err != nil {
                        return res, err
                }
        }

        return res, nil
}

// SaveLocation updates the location in the gdbm with the provided input.
func (h *Handlers) SaveLocation(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        if len(input) > 0 {
                location := string(input)
                store := h.userdataStore
                err = store.WriteEntry(ctx, sessionId, utils.DATA_LOCATION, []byte(location))
                if err != nil {
                        return res, err
                }
        }

        return res, nil
}

// SaveGender updates the gender in the gdbm with the provided input.
func (h *Handlers) SaveGender(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        symbol, _ := h.st.Where()
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        gender := strings.Split(symbol, "_")[1]
        store := h.userdataStore
        err = store.WriteEntry(ctx, sessionId, utils.DATA_GENDER, []byte(gender))
        if err != nil {
                return res, nil
        }

        return res, nil
}

// SaveOfferings updates the offerings(goods and services provided by the user) in the gdbm with the provided input.
func (h *Handlers) SaveOfferings(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        if len(input) > 0 {
                offerings := string(input)
                store := h.userdataStore
                err = store.WriteEntry(ctx, sessionId, utils.DATA_OFFERINGS, []byte(offerings))
                if err != nil {
                        return res, nil
                }
        }

        return res, nil
}

// ResetAllowUpdate resets the allowupdate flag that allows a user to update  profile data.
func (h *Handlers) ResetAllowUpdate(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")

        res.FlagReset = append(res.FlagReset, flag_allow_update)
        return res, nil
}

// ResetAccountAuthorized resets the account authorization flag after a successful PIN entry.
func (h *Handlers) ResetAccountAuthorized(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")

        res.FlagReset = append(res.FlagReset, flag_account_authorized)
        return res, nil
}

// CheckIdentifier retrieves the PublicKey from the JSON data file.
func (h *Handlers) CheckIdentifier(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        store := h.userdataStore
        publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)

        res.Content = string(publicKey)

        return res, nil
}

// Authorize attempts to unlock the next sequential nodes by verifying the provided PIN against the already set PIN.
// It sets the required flags that control the flow.
func (h *Handlers) Authorize(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
        flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")
        flag_allow_update, _ := h.flagManager.GetFlag("flag_allow_update")

        store := h.userdataStore
        AccountPin, err := store.ReadEntry(ctx, sessionId, utils.DATA_ACCOUNT_PIN)
        if err != nil {
                return res, err
        }
        if len(input) == 4 {
                if bytes.Equal(input, AccountPin) {
                        if h.st.MatchFlag(flag_account_authorized, false) {
                                res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
                                res.FlagSet = append(res.FlagSet, flag_allow_update, flag_account_authorized)
                        } else {
                                res.FlagSet = append(res.FlagSet, flag_allow_update)
                                res.FlagReset = append(res.FlagReset, flag_account_authorized)
                        }
                } else {
                        res.FlagSet = append(res.FlagSet, flag_incorrect_pin)
                        res.FlagReset = append(res.FlagReset, flag_account_authorized)
                        return res, nil
                }
        } else {
                return res, nil
        }
        return res, nil
}

// ResetIncorrectPin resets the incorrect pin flag  after a new PIN attempt.
func (h *Handlers) ResetIncorrectPin(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        flag_incorrect_pin, _ := h.flagManager.GetFlag("flag_incorrect_pin")
        res.FlagReset = append(res.FlagReset, flag_incorrect_pin)
        return res, nil
}

// CheckAccountStatus queries the API using the TrackingId and sets flags
// based on the account status
func (h *Handlers) CheckAccountStatus(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_account_success, _ := h.flagManager.GetFlag("flag_account_success")
        flag_account_pending, _ := h.flagManager.GetFlag("flag_account_pending")
        flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        store := h.userdataStore
        trackingId, err := store.ReadEntry(ctx, sessionId, utils.DATA_TRACKING_ID)
        if err != nil {
                return res, err
        }

        accountStatus, err := h.accountService.CheckAccountStatus(string(trackingId))
        if err != nil {
                fmt.Println("Error checking account status:", err)
                return res, err
        }
        if !accountStatus.Ok {
                res.FlagSet = append(res.FlagSet, flag_api_error)
                return res, err
        }
        res.FlagReset = append(res.FlagReset, flag_api_error)
        status := accountStatus.Result.Transaction.Status

        err = store.WriteEntry(ctx, sessionId, utils.DATA_ACCOUNT_STATUS, []byte(status))
        if err != nil {
                return res, nil
        }
        if accountStatus.Result.Transaction.Status == "SUCCESS" {
                res.FlagSet = append(res.FlagSet, flag_account_success)
                res.FlagReset = append(res.FlagReset, flag_account_pending)
        } else {
                res.FlagReset = append(res.FlagReset, flag_account_success)
                res.FlagSet = append(res.FlagSet, flag_account_pending)
        }
        return res, nil
}

// Quit displays the Thank you message and exits the menu
func (h *Handlers) Quit(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")

        code := codeFromCtx(ctx)
        l := gotext.NewLocale(translationDir, code)
        l.AddDomain("default")

        res.Content = l.Get("Thank you for using Sarafu. Goodbye!")
        res.FlagReset = append(res.FlagReset, flag_account_authorized)
        return res, nil
}

// QuitWithHelp displays helpline information then exits the menu
func (h *Handlers) QuitWithHelp(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")

        code := codeFromCtx(ctx)
        l := gotext.NewLocale(translationDir, code)
        l.AddDomain("default")

        res.Content = l.Get("For more help,please call: 0757628885")
        res.FlagReset = append(res.FlagReset, flag_account_authorized)
        return res, nil
}

// VerifyYob verifies the length of the given input
func (h *Handlers) VerifyYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        flag_incorrect_date_format, _ := h.flagManager.GetFlag("flag_incorrect_date_format")

        date := string(input)
        _, err = strconv.Atoi(date)
        if err != nil {
                // If conversion fails, input is not numeric
                res.FlagSet = append(res.FlagSet, flag_incorrect_date_format)
                return res, nil
        }

        if len(date) == 4 {
                res.FlagReset = append(res.FlagReset, flag_incorrect_date_format)
        } else {
                res.FlagSet = append(res.FlagSet, flag_incorrect_date_format)
        }

        return res, nil
}

// ResetIncorrectYob resets the incorrect date format flag after a new attempt
func (h *Handlers) ResetIncorrectYob(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        flag_incorrect_date_format, _ := h.flagManager.GetFlag("flag_incorrect_date_format")

        res.FlagReset = append(res.FlagReset, flag_incorrect_date_format)
        return res, nil
}

// CheckBalance retrieves the balance from the API using the "PublicKey" and sets
// the balance as the result content
func (h *Handlers) CheckBalance(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        store := h.userdataStore
        publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
        if err != nil {
                return res, err
        }

        balanceResponse, err := h.accountService.CheckBalance(string(publicKey))
        if err != nil {
                return res, nil
        }
        if !balanceResponse.Ok {
                res.FlagSet = append(res.FlagSet, flag_api_error)
                return res, nil
        }
        res.FlagReset = append(res.FlagReset, flag_api_error)
        balance := balanceResponse.Result.Balance
        res.Content = balance

        return res, nil
}

func (h *Handlers) FetchCustodialBalances(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        flag_api_error, _ := h.flagManager.GetFlag("flag_api_call_error")

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        symbol, _ := h.st.Where()
        balanceType := strings.Split(symbol, "_")[0]

        store := h.userdataStore
        publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
        if err != nil {
                return res, err
        }

        balanceResponse, err := h.accountService.CheckBalance(string(publicKey))
        if err != nil {
                return res, nil
        }
        if !balanceResponse.Ok {
                res.FlagSet = append(res.FlagSet, flag_api_error)
                return res, nil
        }
        res.FlagReset = append(res.FlagReset, flag_api_error)
        balance := balanceResponse.Result.Balance

        switch balanceType {
        case "my":
                res.Content = fmt.Sprintf("Your balance is %s", balance)
        case "community":
                res.Content = fmt.Sprintf("Your community balance is %s", balance)
        default:
                break
        }
        return res, nil
}

// ValidateRecipient validates that the given input is a valid phone number.
func (h *Handlers) ValidateRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        recipient := string(input)

        flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")

        if recipient != "0" {
                // mimic invalid number check
                if recipient == "000" {
                        res.FlagSet = append(res.FlagSet, flag_invalid_recipient)
                        res.Content = recipient

                        return res, nil
                }
                store := h.userdataStore
                err = store.WriteEntry(ctx, sessionId, utils.DATA_RECIPIENT, []byte(recipient))
                if err != nil {
                        return res, nil
                }
        }

        return res, nil
}

// TransactionReset resets the previous transaction data (Recipient and Amount)
// as well as the invalid flags
func (h *Handlers) TransactionReset(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        flag_invalid_recipient, _ := h.flagManager.GetFlag("flag_invalid_recipient")
        flag_invalid_recipient_with_invite, _ := h.flagManager.GetFlag("flag_invalid_recipient_with_invite")
        store := h.userdataStore
        err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(""))
        if err != nil {
                return res, nil
        }

        err = store.WriteEntry(ctx, sessionId, utils.DATA_RECIPIENT, []byte(""))
        if err != nil {
                return res, nil
        }

        res.FlagReset = append(res.FlagReset, flag_invalid_recipient, flag_invalid_recipient_with_invite)

        return res, nil
}

// ResetTransactionAmount resets the transaction amount and invalid flag
func (h *Handlers) ResetTransactionAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        flag_invalid_amount, _ := h.flagManager.GetFlag("flag_invalid_amount")
        store := h.userdataStore
        err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(""))
        if err != nil {
                return res, nil
        }

        res.FlagReset = append(res.FlagReset, flag_invalid_amount)

        return res, nil
}

// MaxAmount gets the current balance from the API and sets it as
// the result content.
func (h *Handlers) MaxAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        store := h.userdataStore
        publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)

        balanceResp, err := h.accountService.CheckBalance(string(publicKey))
        if err != nil {
                return res, nil
        }
        balance := balanceResp.Result.Balance

        res.Content = balance

        return res, nil
}

// ValidateAmount ensures that the given input is a valid amount and that
// it is not more than the current balance.
func (h *Handlers) ValidateAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        flag_invalid_amount, _ := h.flagManager.GetFlag("flag_invalid_amount")

        store := h.userdataStore
        publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)

        amountStr := string(input)

        balanceRes, err := h.accountService.CheckBalance(string(publicKey))
        balanceStr := balanceRes.Result.Balance

        if err != nil {
                return res, err
        }
        res.Content = balanceStr

        // Parse the balance
        balanceParts := strings.Split(balanceStr, " ")
        if len(balanceParts) != 2 {
                return res, fmt.Errorf("unexpected balance format: %s", balanceStr)
        }
        balanceValue, err := strconv.ParseFloat(balanceParts[0], 64)
        if err != nil {
                return res, fmt.Errorf("failed to parse balance: %v", err)
        }

        // Extract numeric part from input
        re := regexp.MustCompile(`^(\d+(\.\d+)?)\s*(?:CELO)?$`)
        matches := re.FindStringSubmatch(strings.TrimSpace(amountStr))
        if len(matches) < 2 {
                res.FlagSet = append(res.FlagSet, flag_invalid_amount)
                res.Content = amountStr
                return res, nil
        }

        inputAmount, err := strconv.ParseFloat(matches[1], 64)
        if err != nil {
                res.FlagSet = append(res.FlagSet, flag_invalid_amount)
                res.Content = amountStr
                return res, nil
        }

        if inputAmount > balanceValue {
                res.FlagSet = append(res.FlagSet, flag_invalid_amount)
                res.Content = amountStr
                return res, nil
        }

        res.Content = fmt.Sprintf("%.3f", inputAmount) // Format to 3 decimal places
        err = store.WriteEntry(ctx, sessionId, utils.DATA_AMOUNT, []byte(amountStr))
        if err != nil {
                return res, err
        }

        return res, nil
}

// GetRecipient returns the transaction recipient from the gdbm.
func (h *Handlers) GetRecipient(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        store := h.userdataStore
        recipient, _ := store.ReadEntry(ctx, sessionId, utils.DATA_RECIPIENT)

        res.Content = string(recipient)

        return res, nil
}

// GetSender retrieves the public key from the Gdbm Db
func (h *Handlers) GetSender(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        store := h.userdataStore
        publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)

        res.Content = string(publicKey)

        return res, nil
}

// GetAmount retrieves the amount from teh Gdbm Db
func (h *Handlers) GetAmount(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result

        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        store := h.userdataStore
        amount, _ := store.ReadEntry(ctx, sessionId, utils.DATA_AMOUNT)

        res.Content = string(amount)

        return res, nil
}

// QuickWithBalance retrieves the balance for a given public key from the custodial balance API endpoint before
// gracefully exiting the session.
func (h *Handlers) QuitWithBalance(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        flag_account_authorized, _ := h.flagManager.GetFlag("flag_account_authorized")

        code := codeFromCtx(ctx)
        l := gotext.NewLocale(translationDir, code)
        l.AddDomain("default")

        store := h.userdataStore
        publicKey, err := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)
        if err != nil {
                return res, err
        }
        balance, err := h.accountService.CheckBalance(string(publicKey))
        if err != nil {
                return res, nil
        }
        res.Content = l.Get("Your account balance is %s", balance)
        res.FlagReset = append(res.FlagReset, flag_account_authorized)
        return res, nil
}

// InitiateTransaction returns a confirmation and resets the transaction data
// on the gdbm store.
func (h *Handlers) InitiateTransaction(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var err error
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }

        code := codeFromCtx(ctx)
        l := gotext.NewLocale(translationDir, code)
        l.AddDomain("default")
        // TODO
        // Use the amount, recipient and sender to call the API and initialize the transaction
        store := h.userdataStore
        publicKey, _ := store.ReadEntry(ctx, sessionId, utils.DATA_PUBLIC_KEY)

        amount, _ := store.ReadEntry(ctx, sessionId, utils.DATA_AMOUNT)

        recipient, _ := store.ReadEntry(ctx, sessionId, utils.DATA_RECIPIENT)

        res.Content = l.Get("Your request has been sent. %s will receive %s from %s.", string(recipient), string(amount), string(publicKey))

        account_authorized_flag, err := h.flagManager.GetFlag("flag_account_authorized")
        if err != nil {
                return res, err
        }

        res.FlagReset = append(res.FlagReset, account_authorized_flag)
        return res, nil
}

func (h *Handlers) GetProfileInfo(ctx context.Context, sym string, input []byte) (resource.Result, error) {
        var res resource.Result
        var defaultValue string
        sessionId, ok := ctx.Value("SessionId").(string)
        if !ok {
                return res, fmt.Errorf("missing session")
        }
        language, ok := ctx.Value("Language").(lang.Language)
        if !ok {
                return res, fmt.Errorf("value for 'Language' is not of type lang.Language")
        }
        code := language.Code
        if code == "swa" {
                defaultValue = "Haipo"
        } else {
                defaultValue = "Not Provided"
        }

        // Helper function to handle nil byte slices and convert them to string
        getEntryOrDefault := func(entry []byte, err error) string {
                if err != nil || entry == nil {
                        return defaultValue
                }
                return string(entry)
        }
        store := h.userdataStore
        // Retrieve user data as strings with fallback to defaultValue
        firstName := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_FIRST_NAME))
        familyName := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_FAMILY_NAME))
        yob := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_YOB))
        gender := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_GENDER))
        location := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_LOCATION))
        offerings := getEntryOrDefault(store.ReadEntry(ctx, sessionId, utils.DATA_OFFERINGS))

        // Construct the full name
        name := defaultValue
        if familyName != defaultValue {
                if firstName == defaultValue {
                        name = familyName
                } else {
                        name = firstName + " " + familyName
                }
        }

        // Calculate age from year of birth
        age := defaultValue
        if yob != defaultValue {
                if yobInt, err := strconv.Atoi(yob); err == nil {
                        age = strconv.Itoa(utils.CalculateAgeWithYOB(yobInt))
                } else {
                        return res, fmt.Errorf("invalid year of birth: %v", err)
                }
        }
        switch language.Code {
        case "eng":
                res.Content = fmt.Sprintf(
                        "Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n",
                        name, gender, age, location, offerings,
                )
        case "swa":
                res.Content = fmt.Sprintf(
                        "Jina: %s\nJinsia: %s\nUmri: %s\nEneo: %s\nUnauza: %s\n",
                        name, gender, age, location, offerings,
                )
        default:
                res.Content = fmt.Sprintf(
                        "Name: %s\nGender: %s\nAge: %s\nLocation: %s\nYou provide: %s\n",
                        name, gender, age, location, offerings,
                )
        }

        return res, nil
}

package http

import (
        "io"
        "net/http"

        "git.grassecon.net/urdt/ussd/internal/handlers"
)

type ATSessionHandler struct {
        *SessionHandler
}

func NewATSessionHandler(h handlers.RequestHandler) *ATSessionHandler {
        return &ATSessionHandler{
                SessionHandler: ToSessionHandler(h),
        }
}

func (ash *ATSessionHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
        var code int
        var err error

        rqs := handlers.RequestSession{
                Ctx:    req.Context(),
                Writer: w,
        }

        rp := ash.GetRequestParser()
        cfg := ash.GetConfig()
        cfg.SessionId, err = rp.GetSessionId(req)
        if err != nil {
                logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
                ash.writeError(w, 400, err)
                return
        }
        rqs.Config = cfg
        rqs.Input, err = rp.GetInput(req)
        if err != nil {
                logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
                ash.writeError(w, 400, err)
                return
        }

        rqs, err = ash.Process(rqs) 
        switch err {
        case nil: // set code to 200 if no err
                code = 200
        case handlers.ErrStorage, handlers.ErrEngineInit, handlers.ErrEngineExec, handlers.ErrEngineType:
                code = 500
        default:
                code = 500
        }

        if code != 200 {
                ash.writeError(w, 500, err)
                return
        }

        w.WriteHeader(200)
        w.Header().Set("Content-Type", "text/plain")
        rqs, err = ash.Output(rqs)
        if err != nil {
                ash.writeError(w, 500, err)
                return
        }

        rqs, err = ash.Reset(rqs)
        if err != nil {
                ash.writeError(w, 500, err)
                return
        }
}

func (ash *ATSessionHandler) Output(rqs handlers.RequestSession) (handlers.RequestSession, error) {
        var err error
        var prefix string

        if rqs.Continue {
                prefix = "CON "
        } else {
                prefix = "END "
        }

        _, err = io.WriteString(rqs.Writer, prefix)
        if err != nil {
                return rqs, err
        }

        _, err = rqs.Engine.Flush(rqs.Ctx, rqs.Writer)
        return rqs, err
}

package http

import (
        "io/ioutil"
        "net/http"
        "strconv"

        "git.defalsify.org/vise.git/logging"

        "git.grassecon.net/urdt/ussd/internal/handlers"
)

var (
        logg = logging.NewVanilla().WithDomain("httpserver")
)

type DefaultRequestParser struct {
}


func(rp *DefaultRequestParser) GetSessionId(rq any) (string, error) {
        rqv, ok := rq.(*http.Request)
        if !ok {
                return "", handlers.ErrInvalidRequest
        }
        v := rqv.Header.Get("X-Vise-Session")
        if v == "" {
                return "", handlers.ErrSessionMissing
        }
        return v, nil
}

func(rp *DefaultRequestParser) GetInput(rq any) ([]byte, error) {
        rqv, ok := rq.(*http.Request)
        if !ok {
                return nil, handlers.ErrInvalidRequest
        }
        defer rqv.Body.Close()
        v, err := ioutil.ReadAll(rqv.Body)
        if err != nil {
                return nil, err
        }
        return v, nil
}

type SessionHandler struct {
        handlers.RequestHandler
}

func ToSessionHandler(h handlers.RequestHandler) *SessionHandler {
        return &SessionHandler{
                RequestHandler: h,
        }
}

func(f *SessionHandler) writeError(w http.ResponseWriter, code int, err error) {
        s := err.Error()
        w.Header().Set("Content-Length", strconv.Itoa(len(s)))
        w.WriteHeader(code)
        _, err = w.Write([]byte{})
        if err != nil {
                logg.Errorf("error writing error!!", "err", err, "olderr", s)
                w.WriteHeader(500)
        }
        return 
}

func(f *SessionHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
        var code int
        var err error
        var perr error

        rqs := handlers.RequestSession{
                Ctx: req.Context(),
                Writer: w,
        }

        rp := f.GetRequestParser()
        cfg := f.GetConfig()
        cfg.SessionId, err = rp.GetSessionId(req)
        if err != nil {
                logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
                f.writeError(w, 400, err)
        }
        rqs.Config = cfg
        rqs.Input, err = rp.GetInput(req)
        if err != nil {
                logg.ErrorCtxf(rqs.Ctx, "", "header processing error", err)
                f.writeError(w, 400, err)
                return
        }

        rqs, err = f.Process(rqs)
        switch err {
        case handlers.ErrStorage:
                code = 500
        case handlers.ErrEngineInit:
                code = 500
        case handlers.ErrEngineExec:
                code = 500
        default:
                code = 200
        }

        if code != 200 {
                f.writeError(w, 500, err)
                return
        }

        w.WriteHeader(200)
        w.Header().Set("Content-Type", "text/plain")
        rqs, err = f.Output(rqs)
        rqs, perr = f.Reset(rqs)
        if err != nil {
                f.writeError(w, 500, err)
                return
        }
        if perr != nil {
                f.writeError(w, 500, perr)
                return
        }
}

package mocks

import (
        "context"

        "git.defalsify.org/vise.git/lang"
        "github.com/stretchr/testify/mock"
)

type MockDb struct {
        mock.Mock
}

func (m *MockDb) SetPrefix(prefix uint8) {
        m.Called(prefix)
}

func (m *MockDb) Prefix() uint8 {
        args := m.Called()
        return args.Get(0).(uint8)
}

func (m *MockDb) Safe() bool {
        args := m.Called()
        return args.Get(0).(bool)
}

func (m *MockDb) SetLanguage(language *lang.Language) {
        m.Called(language)
}

func (m *MockDb) SetLock(uint8, bool) error {
        args := m.Called()
        return args.Error(0)
}

func (m *MockDb) Connect(ctx context.Context, connectionStr string) error {
        args := m.Called(ctx, connectionStr)
        return args.Error(0)
}

func (m *MockDb) SetSession(sessionId string) {
        m.Called(sessionId)
}

func (m *MockDb) Put(ctx context.Context, key, value []byte) error {
        args := m.Called(ctx, key, value)
        return args.Error(0)
}

func (m *MockDb) Get(ctx context.Context, key []byte) ([]byte, error) {
        args := m.Called(ctx, key)
        return nil, args.Error(0)
}

func (m *MockDb) Close() error {
        args := m.Called(nil)
        return args.Error(0)
}

package httpmocks

import (
        "context"
        "io"
)

// MockEngine implements the engine.Engine interface for testing
type MockEngine struct {
        InitFunc   func(context.Context) (bool, error)
        ExecFunc   func(context.Context, []byte) (bool, error)
        FlushFunc  func(context.Context, io.Writer) (int, error)
        FinishFunc func() error
}

func (m *MockEngine) Init(ctx context.Context) (bool, error) {
        return m.InitFunc(ctx)
}

func (m *MockEngine) Exec(ctx context.Context, input []byte) (bool, error) {
        return m.ExecFunc(ctx, input)
}

func (m *MockEngine) Flush(ctx context.Context, w io.Writer) (int, error) {
        return m.FlushFunc(ctx, w)
}

func (m *MockEngine) Finish() error {
        return m.FinishFunc()
}

package httpmocks

import (
        "git.defalsify.org/vise.git/engine"
        "git.defalsify.org/vise.git/persist"
        "git.defalsify.org/vise.git/resource"
        "git.grassecon.net/urdt/ussd/internal/handlers"
)

// MockRequestHandler implements handlers.RequestHandler interface for testing
type MockRequestHandler struct {
        ProcessFunc          func(handlers.RequestSession) (handlers.RequestSession, error)
        GetConfigFunc        func() engine.Config
        GetEngineFunc        func(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine
        OutputFunc           func(rs handlers.RequestSession) (handlers.RequestSession, error)
        ResetFunc            func(rs handlers.RequestSession) (handlers.RequestSession, error)
        ShutdownFunc         func()
        GetRequestParserFunc func() handlers.RequestParser
}

func (m *MockRequestHandler) Process(rqs handlers.RequestSession) (handlers.RequestSession, error) {
        return m.ProcessFunc(rqs)
}

func (m *MockRequestHandler) GetConfig() engine.Config {
        return m.GetConfigFunc()
}

func (m *MockRequestHandler) GetEngine(cfg engine.Config, rs resource.Resource, pe *persist.Persister) engine.Engine {
        return m.GetEngineFunc(cfg, rs, pe)
}

func (m *MockRequestHandler) Output(rs handlers.RequestSession) (handlers.RequestSession, error) {
        return m.OutputFunc(rs)
}

func (m *MockRequestHandler) Reset(rs handlers.RequestSession) (handlers.RequestSession, error) {
        return m.ResetFunc(rs)
}

func (m *MockRequestHandler) Shutdown() {
        m.ShutdownFunc()
}

func (m *MockRequestHandler) GetRequestParser() handlers.RequestParser {
        return m.GetRequestParserFunc()
}

package httpmocks

// MockRequestParser implements the handlers.RequestParser interface for testing
type MockRequestParser struct {
        GetSessionIdFunc func(any) (string, error)
        GetInputFunc     func(any) ([]byte, error)
}

func (m *MockRequestParser) GetSessionId(rq any) (string, error) {
        return m.GetSessionIdFunc(rq)
}

func (m *MockRequestParser) GetInput(rq any) ([]byte, error) {
        return m.GetInputFunc(rq)
}

package httpmocks

import "net/http"

// MockWriter implements a mock io.Writer for testing
type MockWriter struct {
        WriteStringCalled bool
        WrittenString     string
}

func (m *MockWriter) Write(p []byte) (n int, err error) {
        return len(p), nil
}

func (m *MockWriter) WriteString(s string) (n int, err error) {
        m.WriteStringCalled = true
        m.WrittenString = s
        return len(s), nil
}

func (m *MockWriter) Header() http.Header {
        return http.Header{}
}

func (m *MockWriter) WriteHeader(statusCode int) {}

package mocks

import (
        "git.grassecon.net/urdt/ussd/internal/models"
        "github.com/stretchr/testify/mock"
)

// MockAccountService implements AccountServiceInterface for testing
type MockAccountService struct {
        mock.Mock
}

func (m *MockAccountService) CreateAccount() (*models.AccountResponse, error) {
        args := m.Called()
        return args.Get(0).(*models.AccountResponse), args.Error(1)
}

func (m *MockAccountService) CheckBalance(publicKey string) (*models.BalanceResponse, error) {
        args := m.Called(publicKey)
        return args.Get(0).(*models.BalanceResponse), args.Error(1)
}

func (m *MockAccountService) CheckAccountStatus(trackingId string) (*models.TrackStatusResponse, error) {
        args := m.Called(trackingId)
        return args.Get(0).(*models.TrackStatusResponse), args.Error(1)
}

package mocks

import (
        "context"

        "git.defalsify.org/vise.git/db"
        "git.grassecon.net/urdt/ussd/internal/utils"
        "github.com/stretchr/testify/mock"
)

type MockUserDataStore struct {
        db.Db
        mock.Mock
}

func (m *MockUserDataStore) ReadEntry(ctx context.Context, sessionId string, typ utils.DataTyp) ([]byte, error) {
        args := m.Called(ctx, sessionId, typ)
        return args.Get(0).([]byte), args.Error(1)
}

func (m *MockUserDataStore) WriteEntry(ctx context.Context, sessionId string, typ utils.DataTyp, value []byte) error {
        args := m.Called(ctx, sessionId, typ, value)
        return args.Error(0)
}

package storage

import (
        "context"

        "git.defalsify.org/vise.git/db"
        "git.defalsify.org/vise.git/lang"
        gdbmdb "git.defalsify.org/vise.git/db/gdbm"
)

var (
        dbC map[string]chan db.Db
)

type ThreadGdbmDb struct {
        db db.Db
        connStr string
}

func NewThreadGdbmDb() *ThreadGdbmDb {
        if dbC == nil {
                dbC = make(map[string]chan db.Db)
        }
        return &ThreadGdbmDb{}
}

func(tdb *ThreadGdbmDb) Connect(ctx context.Context, connStr string) error {
        var ok bool
        _, ok = dbC[connStr]
        if ok {
                logg.WarnCtxf(ctx, "already registered thread gdbm, skipping", "connStr", connStr)
                return nil
        }
        gdb := gdbmdb.NewGdbmDb()
        err := gdb.Connect(ctx, connStr)
        if err != nil {
                return err
        }
        dbC[connStr] = make(chan db.Db, 1)
        dbC[connStr]<- gdb
        tdb.connStr = connStr
        return nil
}

func(tdb *ThreadGdbmDb) reserve() {
        if tdb.db == nil {
                tdb.db = <-dbC[tdb.connStr]
        }
}

func(tdb *ThreadGdbmDb) release() {
        if tdb.db == nil {
                return
        }
        dbC[tdb.connStr] <- tdb.db
        tdb.db = nil
}

func(tdb *ThreadGdbmDb) SetPrefix(pfx uint8) {
        tdb.reserve()
        tdb.db.SetPrefix(pfx)
}

func(tdb *ThreadGdbmDb) SetSession(sessionId string) {
        tdb.reserve()
        tdb.db.SetSession(sessionId)
}

func(tdb *ThreadGdbmDb) SetLanguage(lng *lang.Language) {
        tdb.reserve()
        tdb.db.SetLanguage(lng)
}

func(tdb *ThreadGdbmDb) Safe() bool {
        tdb.reserve()
        v := tdb.db.Safe()
        tdb.release()
        return v
}

func(tdb *ThreadGdbmDb) Prefix() uint8 {
        tdb.reserve()
        v := tdb.db.Prefix()
        tdb.release()
        return v
}

func(tdb *ThreadGdbmDb) SetLock(typ uint8, locked bool) error {
        tdb.reserve()
        err := tdb.db.SetLock(typ, locked)
        tdb.release()
        return err
}

func(tdb *ThreadGdbmDb) Put(ctx context.Context, key []byte, val []byte) error {
        tdb.reserve()
        err := tdb.db.Put(ctx, key, val)
        tdb.release()
        return err
}

func(tdb *ThreadGdbmDb) Get(ctx context.Context, key []byte) ([]byte, error) {
        tdb.reserve()
        v, err := tdb.db.Get(ctx, key)
        tdb.release()
        return v, err
}

func(tdb *ThreadGdbmDb) Close() error {
        tdb.reserve()
        close(dbC[tdb.connStr])
        err := tdb.db.Close()
        tdb.db = nil
        return err
}

package storage

import (
        "git.defalsify.org/vise.git/db"
        "git.defalsify.org/vise.git/persist"
)

const (
        DATATYPE_CUSTOM = 128 
)

type Storage struct {
        Persister *persist.Persister
        UserdataDb db.Db        
}

type StorageProvider interface {
        Get(sessionId string) (*Storage, error)
        Put(sessionId string, storage *Storage) error
        Close() error
}

type SimpleStorageProvider struct {
        *Storage
}

func NewSimpleStorageProvider(stateStore db.Db, userdataStore db.Db) StorageProvider {
        pe := persist.NewPersister(stateStore)
        pe = pe.WithFlush()
        return &SimpleStorageProvider{
                Storage: &Storage{
                        Persister: pe,
                        UserdataDb: userdataStore,
                },
        }
}

func (p *SimpleStorageProvider) Get(sessionId string) (*Storage, error) {
        return p.Storage, nil
}

func (p *SimpleStorageProvider) Put(sessionId string, storage *Storage) error {
        return nil
}

func (p *SimpleStorageProvider) Close() error {
        return p.Storage.UserdataDb.Close()
}

package storage

import (
        "context"
        "fmt"
        "os"
        "path"

        "git.defalsify.org/vise.git/db"
        fsdb "git.defalsify.org/vise.git/db/fs"
        "git.defalsify.org/vise.git/persist"
        "git.defalsify.org/vise.git/resource"
        "git.defalsify.org/vise.git/logging"
)

var (
        logg = logging.NewVanilla().WithDomain("storage")
)        

type StorageService interface {
        GetPersister(ctx context.Context) (*persist.Persister, error)
        GetUserdataDb(ctx context.Context) db.Db
        GetResource(ctx context.Context) (resource.Resource, error)
        EnsureDbDir() error
}

type MenuStorageService struct{
        dbDir string
        resourceDir string
        resourceStore db.Db
        stateStore db.Db
        userDataStore db.Db
}

func NewMenuStorageService(dbDir string, resourceDir string) *MenuStorageService {
        return &MenuStorageService{
                dbDir: dbDir,
                resourceDir: resourceDir,
        }
}

func (ms *MenuStorageService) GetPersister(ctx context.Context) (*persist.Persister, error) {
        ms.stateStore = NewThreadGdbmDb()
        storeFile := path.Join(ms.dbDir, "state.gdbm")
        err := ms.stateStore.Connect(ctx, storeFile)
        if err != nil {
                return nil, err
        }
        pr := persist.NewPersister(ms.stateStore)
        logg.TraceCtxf(ctx, "menu storage service", "persist", pr, "store", ms.stateStore)
        return pr, nil
}

func (ms *MenuStorageService) GetUserdataDb(ctx context.Context) (db.Db, error) {
        ms.userDataStore = NewThreadGdbmDb()
        storeFile := path.Join(ms.dbDir, "userdata.gdbm")
        err := ms.userDataStore.Connect(ctx, storeFile)
        if err != nil {
                return nil, err
        }
        return ms.userDataStore, nil
}

func (ms *MenuStorageService) GetResource(ctx context.Context) (resource.Resource, error) {
        ms.resourceStore = fsdb.NewFsDb()
        err := ms.resourceStore.Connect(ctx, ms.resourceDir)
        if err != nil {
                return nil, err
        }
        rfs := resource.NewDbResource(ms.resourceStore)
        return rfs, nil
}

func (ms *MenuStorageService) GetStateStore(ctx context.Context) (db.Db, error) {
        if ms.stateStore != nil {
                panic("set up store when already exists")
        }
        ms.stateStore = NewThreadGdbmDb()
        storeFile := path.Join(ms.dbDir, "state.gdbm")
        err := ms.stateStore.Connect(ctx, storeFile)
        if err != nil {
                return nil, err
        }
        return ms.stateStore, nil
}

func (ms *MenuStorageService) EnsureDbDir() error {
        err := os.MkdirAll(ms.dbDir, 0700)
        if err != nil {
                return fmt.Errorf("state dir create exited with error: %v\n", err)
        }
        return nil
}

func (ms *MenuStorageService) Close() error {
        errA := ms.stateStore.Close()
        errB := ms.userDataStore.Close()
        errC := ms.resourceStore.Close()
        if errA != nil || errB != nil || errC != nil {
                return fmt.Errorf("%v %v %v", errA, errB, errC)
        }
        return nil
}

package utils

import "time"

// CalculateAge calculates the age based on a given birthdate and the current date in the format dd/mm/yy
// It adjusts for cases where the current date is before the birthday in the current year.
func CalculateAge(birthdate, today time.Time) int {
        today = today.In(birthdate.Location())
        ty, tm, td := today.Date()
        today = time.Date(ty, tm, td, 0, 0, 0, 0, time.UTC)
        by, bm, bd := birthdate.Date()
        birthdate = time.Date(by, bm, bd, 0, 0, 0, 0, time.UTC)
        if today.Before(birthdate) {
                return 0
        }
        age := ty - by
        anniversary := birthdate.AddDate(age, 0, 0)
        if anniversary.After(today) {
                age--
        }
        return age
}

// CalculateAgeWithYOB calculates the age based on the given year of birth (YOB).
// It subtracts the YOB from the current year to determine the age.
//
// Parameters:
//   yob: The year of birth as an integer.
//
// Returns:
//   The calculated age as an integer.
func CalculateAgeWithYOB(yob int) int {
    currentYear := time.Now().Year()
    return currentYear - yob
}

package utils

import (
        "encoding/binary"
)

type DataTyp uint16

const (
        DATA_ACCOUNT DataTyp = iota
        DATA_ACCOUNT_CREATED
        DATA_TRACKING_ID
        DATA_PUBLIC_KEY
        DATA_CUSTODIAL_ID
        DATA_ACCOUNT_PIN
        DATA_ACCOUNT_STATUS
        DATA_FIRST_NAME
        DATA_FAMILY_NAME
        DATA_YOB
        DATA_LOCATION
        DATA_GENDER
        DATA_OFFERINGS
        DATA_RECIPIENT
        DATA_AMOUNT
        DATA_TEMPORARY_PIN
)

func typToBytes(typ DataTyp) []byte {
        var b [2]byte
        binary.BigEndian.PutUint16(b[:], uint16(typ))
        return b[:]
}

func PackKey(typ DataTyp, data []byte) []byte {
        v := typToBytes(typ)
        return append(v, data...)
}

package utils

var isoCodes = map[string]bool{
        "eng": true, // English
        "swa": true, // Swahili

}

func IsValidISO639(code string) bool {
        return isoCodes[code]
}

package utils

import (
        "context"

        "git.defalsify.org/vise.git/db"
)

type DataStore interface {
        db.Db
        ReadEntry(ctx context.Context, sessionId string, typ DataTyp) ([]byte, error)
        WriteEntry(ctx context.Context, sessionId string, typ DataTyp, value []byte) error
}

type UserDataStore struct {
        db.Db
}

// ReadEntry retrieves an entry from the store based on the provided parameters.
func (store *UserDataStore) ReadEntry(ctx context.Context, sessionId string, typ DataTyp) ([]byte, error) {
        store.SetPrefix(db.DATATYPE_USERDATA)
        store.SetSession(sessionId)
        k := PackKey(typ, []byte(sessionId))
        return store.Get(ctx, k)
}

func (store *UserDataStore) WriteEntry(ctx context.Context, sessionId string, typ DataTyp, value []byte) error {
        store.SetPrefix(db.DATATYPE_USERDATA)
        store.SetSession(sessionId)
        k := PackKey(typ, []byte(sessionId))
        return store.Put(ctx, k, value)
}