reconciler

var (
	ErrOwnerExists       = errors.New("owner already exists")
	ErrOwnerDoesNotExist = errors.New("owner does not exist")
)

var (
	DesiredRouteIndex = statedb.Index[*DesiredRoute, DesiredRouteKey]{
		Name: "id",
		FromObject: func(d *DesiredRoute) index.KeySet {
			return index.NewKeySet(d.GetFullKey().Key())
		},
		FromKey: DesiredRouteKey.Key,
		FromString: func(s string) (index.Key, error) {
			parts := strings.Split(s, ":")
			if len(parts) > 3 {
				return nil, fmt.Errorf("bad key, expected \"owner[:table[:prefix[:priority]]]\", got %s", s)
			}

			var key DesiredRouteKey
			if len(parts) >= 2 {
				if err := key.Table.FromString(parts[1]); err != nil {
					return nil, fmt.Errorf("bad key, expected \"owner[:table[:prefix[:priority]]]\", got %s: %w", s, err)
				}
			}

			if len(parts) >= 3 {
				var err error
				key.Prefix, err = netip.ParsePrefix(parts[2])
				if err != nil {
					return nil, fmt.Errorf("bad key, expected \"owner[:table[:prefix[:priority]]]\", got %s: %w", s, err)
				}
			}

			if len(parts) >= 4 {
				prio, err := strconv.ParseUint(parts[3], 10, 32)
				if err != nil {
					return nil, fmt.Errorf("bad key, expected \"owner[:table[:prefix[:priority]]]\", got %s: %w", s, err)
				}
				key.Priority = uint32(prio)
			}

			return key.Key(), nil
		},
		Unique: true,
	}

	DesiredRouteTablePrefixIndex = statedb.Index[*DesiredRoute, DesiredRouteKey]{
		Name: "table-prefix",
		FromObject: func(d *DesiredRoute) index.KeySet {
			return index.NewKeySet(d.GetOwnerlessKey().Key())
		},
		FromKey: func(key DesiredRouteKey) index.Key {
			key.Owner = nil
			return key.Key()
		},
		FromString: func(s string) (index.Key, error) {

			parts := strings.Split(s, ":")

			var key DesiredRouteKey
			if err := key.Table.FromString(parts[0]); err != nil {
				return nil, fmt.Errorf("bad key, expected \"table:prefix:priority\", got %s: %w", s, err)
			}

			if len(parts) < 2 {
				return key.Key(), nil
			}

			var err error
			key.Prefix, err = netip.ParsePrefix(parts[1])
			if err != nil {
				return nil, err
			}

			if len(parts) < 3 {
				return key.Key(), nil
			}

			prio, err := strconv.ParseUint(parts[2], 10, 32)
			if err != nil {
				return nil, fmt.Errorf("bad key, expected \"table:prefix:priority\", got %s: %w", s, err)
			}
			key.Priority = uint32(prio)

			return key.Key(), nil
		},
		Unique: false,
	}

	DesiredRouteTableDeviceIndex = statedb.Index[*DesiredRoute, int]{
		Name: "device",
		FromObject: func(obj *DesiredRoute) index.KeySet {
			if obj.Device == nil {
				return index.NewKeySet()
			}
			return index.NewKeySet(index.Int(obj.Device.Index))
		},
		FromKey: func(key int) index.Key {
			return index.Int(key)
		},
		Unique: false,
	}
)

var Cell = cell.Module(
	"route-reconciler",
	"Reconciles desired routes to the Linux kernel routing table",
	TableCell,
	cell.Provide(registerReconciler),
	cell.Invoke(desiredRouteRefresher),
)

var TableCell = cell.Group(
	cell.Provide(newDesiredRouteManager),
	cell.ProvidePrivate(newDesiredRouteTable),
	cell.Provide(statedb.RWTable[*DesiredRoute].ToTable),
)