package internal

import (
	`context`
	`sync`

	`github.com/hashicorp/vault-client-go`
	`r00t2.io/gosecret`
	`r00t2.io/goutils/multierr`
)

func New(vaultTok, vaultAddr, vaultMnt, collNm string) (c *Client, err error) {

	c = &Client{
		// lastIdx:  0,
		vtok:     vaultTok,
		vaddr:    vaultAddr,
		scollNm:  collNm,
		vmnt:     vaultMnt,
		errsDone: make(chan bool, 1),
		errChan:  make(chan error),
		// vc:       nil,
		wg:  sync.WaitGroup{},
		ctx: context.Background(),
		// ssvc:     nil,
		// scoll:    nil,
		mErr: multierr.NewMultiError(nil),
		// inSS:     nil,
		// inVault:  nil,
	}

	if c.vc, err = vault.New(vault.WithAddress(c.vaddr)); err != nil {
		return
	}
	if err = c.vc.SetToken(c.vtok); err != nil {
		return
	}

	if c.ssvc, err = gosecret.NewService(); err != nil {
		return
	}
	if c.scoll, err = c.ssvc.GetCollection(collNm); err != nil {
		return
	}

	go c.readErrs()

	c.wg.Add(2)
	go c.getSS()
	go c.getVault()

	c.wg.Wait()

	if !c.mErr.IsEmpty() {
		err = c.mErr
		return
	}

	return
}

func normalizeVaultNm(nm string) (normalized string) {

	var c rune
	var idx int
	var last rune
	var repl rune = '_'
	var reduced []rune = make([]rune, 0)
	var norm []rune = make([]rune, 0, len(nm))

	for _, c = range nm {
		// If it's "safe" chars, it's fine
		if (c == '-' || c == '.') || // 0x2d, 0x2e
			(c >= '0' && c <= '9') || // 0x30 to 0x39
			(c == '@') || // 0x40
			(c >= 'A' && c <= 'Z') || // 0x41 to 0x5a
			(c == '_') || // 0x5f
			(c >= 'a' && c <= 'z') { // 0x61 to 0x7a
			norm = append(norm, c)
			continue
		}
		// Otherwise normalize it to a safe char
		norm = append(norm, repl)
	}

	// And remove repeating sequential replacers.
	for idx, c = range norm[:] {
		if idx == 0 {
			last = c
			reduced = append(reduced, c)
			continue
		}
		if c == last && last == repl {
			continue
		}
		reduced = append(reduced, c)
		last = c
	}

	normalized = string(reduced)

	return
}