// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2026 Meta Platforms, Inc. and affiliates. */

#include <linux/bits.h>

#define T 32
#include "cnum_defs.h"
#undef T

#define T 64
#include "cnum_defs.h"
#undef T

struct cnum32 cnum32_from_cnum64(struct cnum64 cnum)
{
        if (cnum64_is_empty(cnum))
                return CNUM32_EMPTY;

        if (cnum.size >= U32_MAX)
                return (struct cnum32){ .base = 0, .size = U32_MAX };
        else
                return (struct cnum32){ .base = (u32)cnum.base, .size = cnum.size };
}

/*
 * Suppose 'a' and 'b' are laid out as follows:
 *
 *                                                          64-bit number axis --->
 *
 * N*2^32                   (N+1)*2^32                (N+2)*2^32                (N+3)*2^32
 * ||------|---|=====|-------||----------|=====|-------||----------|=====|----|--||
 *         |   |< b >|                   |< b >|                   |< b >|    |
 *         |   |                                                         |    |
 *         |<--+--------------------------- a ---------------------------+--->|
 *             |                                                         |
 *             |<-------------------------- t -------------------------->|
 *
 * In such a case it is possible to infer a more tight representation t
 * such that ∀ v ∈ a, (u32)v ∈ b: v ∈ t.
 */
struct cnum64 cnum64_cnum32_intersect(struct cnum64 a, struct cnum32 b)
{
        /*
         * To simplify reasoning, rotate the circles so that [virtual] a1 starts
         * at u32 boundary, b1 represents b in this new frame of reference.
         */
        struct cnum32 b1 = { b.base - (u32)a.base, b.size };
        struct cnum64 t = a;
        u64 d, b1_max;

        if (cnum64_is_empty(a) || cnum32_is_empty(b))
                return CNUM64_EMPTY;

        if (cnum32_urange_overflow(b1)) {
                b1_max = (u32)b1.base + (u32)b1.size; /* overflow here is fine and necessary */
                if ((u32)a.size > b1_max && (u32)a.size < b1.base) {
                        /*
                         * N*2^32                   (N+1)*2^32
                         * ||=====|------------|=====||=====|---------|---|=====||
                         *  |b1 ->|            |<- b1||b1 ->|         |   |<- b1|
                         *  |<----------------- a1 ------------------>|
                         *  |<-------------- t ------------>|<-- d -->| (after adjustment)
                         *                                  ^
                         *                                b1_max
                         */
                        d = (u32)a.size - b1_max;
                        t.size -= d;
                } else {
                        /*
                         * No adjustments possible in the following cases:
                         *
                         * ||=====|------------|=====||===|=|-------------|=|===||
                         *  |b1 ->|            |<- b1||b1 +>|             |<+ b1|
                         *  |<----------------- a1 ------>|                 |
                         *  |<----------------- (or) a1 ------------------->|
                         */
                }
        } else {
                if (t.size < b1.base)
                        /*
                         * N*2^32                   (N+1)*2^32
                         * ||----------|--|=======|--||------>
                         *  |<-- a1 -->|  |<- b ->|
                         */
                        return CNUM64_EMPTY;
                /*
                 * N*2^32                   (N+1)*2^32
                 * ||-------------|========|-||-----| -------|========|-||
                 *  |             |<- b1 ->|        |        |<- b1 ->|
                 *  |<------------+ a1 ------------>|
                 *                |<------ t ------>| (after adjustment)
                 */
                t.base += b1.base;
                t.size -= b1.base;
                b1_max = b1.base + b1.size;
                d = 0;
                if ((u32)a.size < b1.base)
                        /*
                         * N*2^32                   (N+1)*2^32
                         * ||-------------|========|-||------|-------|========|-||
                         *  |             |<- b1 ->|         |       |<- b1 ->|
                         *  |<------------+-- a1 --+-------->|
                         *                |<- t  ->|<-- d -->| (after adjustment)
                         */
                        d = (u32)a.size + (BIT_ULL(32) - b1_max);
                else if ((u32)a.size >= b1_max)
                        /*
                         * N*2^32                   (N+1)*2^32
                         * ||--|========|------------||--|========|-------|-----||
                         *  |  |<- b1 ->|                |<- b1 ->|       |
                         *  |<-+------------------ a1 ------------+------>|
                         *     |<-------------- t --------------->|<- d ->| (after adjustment)
                         */
                        d = (u32)a.size - b1_max;
                if (t.size < d)
                        return CNUM64_EMPTY;
                t.size -= d;
        }
        return t;
}