"""Fictitious in-memory session selection. No HTTP or SAP protocol simulation."""
from dataclasses import dataclass, replace, field


@dataclass(frozen=True)
class Scope:
    connection_profile: str
    company_db: str
    principal: str


@dataclass(frozen=True)
class Lease:
    scope: Scope
    cookie: str | None = field(repr=False)
    generation: int
    route_id: str | None
    observed_expired: bool = False


class Pool:
    def __init__(self):
        self.generations = {}
        self.records = {}

    def begin_login(self, scope):
        generation = self.generations.get(scope, 0) + 1
        self.generations[scope] = generation
        return generation

    def remember(self, lease):
        if self.generations.get(lease.scope) != lease.generation:
            return False
        self.records[lease.scope] = lease
        return True

    def prepare(self, expected_scope, lease):
        if lease.scope != expected_scope:
            return 'REVIEW_SCOPE'
        if not lease.cookie:
            return 'SESSION_COOKIE_MISSING'
        if lease.observed_expired:
            return 'SESSION_ALREADY_OBSERVED_EXPIRED'
        if self.generations.get(expected_scope) != lease.generation:
            return 'STALE_LOCAL_LOGIN_GENERATION'
        return 'LOCAL_BINDING_READY_NOT_SAP_VALIDATED'


def main():
    checks = 0

    def check(condition):
        nonlocal checks
        checks += 1
        if not condition:
            raise AssertionError('Local check failed: ' + str(checks))

    a = Scope('connection-prod', 'company-A', 'integration-reader')
    b = Scope('connection-prod', 'company-B', 'integration-reader')
    pool = Pool()
    lease_a = Lease(a, 'fictitious-cookie-A', pool.begin_login(a), '.node0')
    lease_b = Lease(b, 'fictitious-cookie-B', pool.begin_login(b), '.node0')
    check(pool.remember(lease_a))
    check(pool.remember(lease_b))
    # Company markers and quantities are local teaching data, not SAP fields.
    fake_records = {
        'fictitious-cookie-A': ('company-A', 10),
        'fictitious-cookie-B': ('company-B', 80),
        'fictitious-cookie-A2': ('company-A', 10),
    }
    last_cookie = lease_a.cookie
    last_cookie = lease_b.cookie
    wrong_company, wrong_quantity = fake_records[last_cookie]
    check(wrong_company == 'company-B')
    check(wrong_quantity == 80)
    print('Global last-cookie variable selects company-B for an intended company-A job.')

    selected = []
    for scope in (a, b, a):
        lease = pool.records[scope]
        check(pool.prepare(scope, lease) == 'LOCAL_BINDING_READY_NOT_SAP_VALIDATED')
        selected.append(fake_records[lease.cookie][1])
    check(selected == [10, 80, 10])
    print('Partitioned selection A, B, A returns local quantities 10, 80, 10.')

    wrong_leases = (
        lease_b,
        replace(lease_a, scope=replace(a, connection_profile='connection-staging')),
        replace(lease_a, scope=replace(a, principal='another-reader')),
    )
    for lease in wrong_leases:
        check(pool.prepare(a, lease) == 'REVIEW_SCOPE')
    check(pool.prepare(a, replace(lease_a, cookie=None)) == 'SESSION_COOKIE_MISSING')
    check(pool.prepare(a, replace(lease_a, observed_expired=True)) == 'SESSION_ALREADY_OBSERVED_EXPIRED')
    unchanged_b = pool.records[b]
    generation_a2 = pool.begin_login(a)
    check(pool.prepare(a, lease_a) == 'STALE_LOCAL_LOGIN_GENERATION')
    check(pool.remember(lease_a) is False)
    lease_a2 = replace(lease_a, cookie='fictitious-cookie-A2', generation=generation_a2)
    check(pool.remember(lease_a2))
    check(pool.prepare(a, lease_a2) == 'LOCAL_BINDING_READY_NOT_SAP_VALIDATED')
    check(pool.records[b] is unchanged_b)
    check(pool.prepare(a, replace(lease_a2, route_id=None)) == 'LOCAL_BINDING_READY_NOT_SAP_VALIDATED')
    check(lease_b.observed_expired is False)
    check(lease_a.generation == 1)
    print('8 scenarios and ' + str(checks) + ' checks passed. No HTTP call, SAP validation or remote write performed.')


if __name__ == '__main__':
    main()