package gitpb

import (
	"errors"
	"fmt"
	"strconv"
	"strings"

	"go.wit.com/log"
)

// newver(0.25.101-1+b10)
// a == 0
// b == 25
// c == 101
// pnum == 1
// bnum == 10
type Vers struct {
	a    int // major
	b    int
	c    int
	pnum int
	bnum int
}

func TokenVersions(ver string) (*Vers, error) {
	var err error
	tok := new(Vers)
	var golang bool
	if strings.HasPrefix(ver, "v") {
		golang = true
		ver = strings.TrimPrefix(ver, "v")
	}
	parts := strings.Split(ver, "-")
	if len(parts) == 0 {
		return nil, errors.New("version was empty")
	}
	abc := strings.Split(parts[0], ".")
	if len(abc) != 3 {
		return nil, errors.New("abc != 3 parts")
	}
	tok.a, err = strconv.Atoi(abc[0])
	if err != nil {
		return nil, errors.New("tok.a failed")
	}
	tok.b, err = strconv.Atoi(abc[1])
	if err != nil {
		return nil, errors.New("tok.b failed")
	}
	tok.c, err = strconv.Atoi(abc[2])
	if err != nil {
		return nil, errors.New("tok.c failed")
	}
	if golang {
		return tok, nil
	}

	if len(parts) != 2 {
		return nil, errors.Join(err, errors.New("len != 2 parts"))
	}
	bb := strings.Split(parts[1], "+")
	if len(bb) != 2 {
		return nil, errors.Join(err, errors.New(fmt.Sprintf("parts(%v) abc(%v)", parts, abc)))
	}
	tok.pnum, err = strconv.Atoi(bb[0])
	if err != nil {
		return nil, errors.Join(err, errors.New(fmt.Sprintf("parts(%v) abc(%v)", parts, abc)))
	}
	tok.bnum, err = strconv.Atoi(strings.TrimPrefix(bb[1], "b"))
	if err != nil {
		return nil, errors.Join(err, errors.New(fmt.Sprintf("parts(%v) abc(%v)", parts, abc)))
	}
	return tok, nil
}

func CompareVers(atok *Vers, btok *Vers) int {
	if (atok == nil) || (btok == nil) {
		return 0
	}
	// CHECK A
	if atok.a > btok.a {
		return 1
	}
	if btok.a > atok.a {
		return -1
	}

	// CHECK B
	if atok.b > btok.b {
		return 1
	}
	if btok.b > atok.b {
		return -1
	}

	// CHECK C
	if atok.c > btok.c {
		return 1
	}
	if btok.c > atok.c {
		return -1
	}

	// CHECK PATCH #
	if atok.pnum > btok.pnum {
		return 1
	}
	if btok.pnum > atok.pnum {
		return -1
	}

	// CHECK BUILD #
	if atok.bnum > btok.bnum {
		return 1
	}
	if btok.bnum > atok.bnum {
		return -1
	}

	// CHECK IS EQUAL
	if atok.bnum == btok.bnum {
		return 0
	}
	return 0 // compare should not have gotten here (%v) to curver (%v)", newver, curver))
}

// compares newver(0.25.101-1+b10) curver(0.25.101-5+b1)
// returns true only if it's newer. returns false if equal
// used for .deb mirrors
func NewerVersion(newver string, curver string) (bool, error) {
	newtok, err1 := TokenVersions(newver)
	curtok, err2 := TokenVersions(curver)
	if (newtok == nil) || (curtok == nil) {
		s := log.Sprintf("token on the railroad failed (%v) to curver (%v) err(%v)(%v)", newtok, curtok, err1, err2)
		return false, errors.New(s)
	}
	// CHECK A
	if newtok.a > curtok.a {
		return true, nil
	}
	if curtok.a > newtok.a {
		return false, errors.New(log.Sprintf("A.x.x lower (%v) to curver (%v)", newver, curver))
	}

	// CHECK B
	if newtok.b > curtok.b {
		return true, nil
	}
	if curtok.b > newtok.b {
		return false, errors.New(log.Sprintf("x.B.x lower (%v) to curver (%v)", newver, curver))
	}

	// CHECK C
	if newtok.c > curtok.c {
		return true, nil
	}
	if curtok.c > newtok.c {
		return false, errors.New(log.Sprintf("x.x.C lower (%v) to curver (%v)", newver, curver))
	}

	// CHECK PATCH #
	if newtok.pnum > curtok.pnum {
		return true, nil
	}
	if curtok.pnum > newtok.pnum {
		return false, errors.New(log.Sprintf("patch # lower (%v) to curver (%v)", newver, curver))
	}

	// CHECK BUILD #
	if newtok.bnum > curtok.bnum {
		return true, nil
	}
	if curtok.bnum > newtok.bnum {
		return false, errors.New(log.Sprintf("build # lower (%v) to curver (%v)", newver, curver))
	}

	// CHECK IS EQUAL
	if curtok.bnum == newtok.bnum {
		return false, errors.New(log.Sprintf("new is equal (%v) to curver (%v)", newver, curver))
	}
	return false, errors.New(log.Sprintf("compare should not have gotten here (%v) to curver (%v)", newver, curver))
}