চূড়ান্ত প্রকল্প — একটি ফুল-স্ট্যাক অ্যাপ্লিকেশন ডিজাইন ও সিমুলেট করা

# ========== মডিউল ১: In-memory CRUD "ডেটাবেস" -- টাস্কের জন্য ==========
TASKS_DB = {}        # id (int) থেকে রেকর্ড dict -- সত্যিকারের ডেটাবেস টেবিলের ভূমিকায়
_next_task_id = 1

def db_create_task(title, owner):
    global _next_task_id
    record = {"id": _next_task_id, "title": title, "done": False, "owner": owner}
    TASKS_DB[_next_task_id] = record
    _next_task_id += 1
    return dict(record)

def db_read_task(task_id):
    record = TASKS_DB.get(task_id)
    return dict(record) if record else None

def db_list_tasks():
    return [dict(r) for r in TASKS_DB.values()]

def db_update_task(task_id, **fields):
    record = TASKS_DB.get(task_id)
    if record is None:
        return None
    record.update(fields)
    return dict(record)

def db_delete_task(task_id):
    return TASKS_DB.pop(task_id, None) is not None


# ---- স্যানিটি-চেক: CRUD ফাংশনগুলো সরাসরি টেস্ট করা ----
demo = db_create_task("ডেমো টাস্ক (শুধু CRUD যাচাইয়ের জন্য)", owner="system")
print("তৈরি:      ", demo)
print("পড়া:       ", db_read_task(demo["id"]))
print("আপডেট:     ", db_update_task(demo["id"], done=True))
print("তালিকা:    ", db_list_tasks())
print("মোছা হলো:  ", db_delete_task(demo["id"]))
print("মোছার পর:  ", db_list_tasks())

# ========== মডিউল ২: মিনি ORM -- Task মডেল, উপরের CRUD ডেটাবেস র‍্যাপ করে ==========
class Manager:
    def __init__(self, model_cls, list_fn):
        self.model_cls = model_cls
        self.list_fn = list_fn

    def filter(self, **kwargs):
        rows = [r for r in self.list_fn() if all(r.get(k) == v for k, v in kwargs.items())]
        return [self.model_cls(**r) for r in rows]

    def all(self):
        return self.filter()


class Task:
    def __init__(self, id, title, done, owner):
        self.id = id
        self.title = title
        self.done = done
        self.owner = owner

    @classmethod
    def create(cls, title, owner):
        record = db_create_task(title, owner)
        return cls(**record)

    def save(self):
        db_update_task(self.id, title=self.title, done=self.done, owner=self.owner)
        return self

    def __repr__(self):
        mark = "[x]" if self.done else "[ ]"
        return f"{mark} #{self.id} {self.title} (owner={self.owner})"


Task.objects = Manager(Task, db_list_tasks)

# ---- মিনি-ORM যাচাই: তৈরি, ফিল্টার, আপডেট, আবার পড়া ----
task_a = Task.create(title="ডিজাইন রিভিউ", owner="rafiq")
task_b = Task.create(title="ডেপ্লয়মেন্ট চেকলিস্ট", owner="rafiq")
task_c = Task.create(title="মিটিং নোট", owner="admin")

print("সব টাস্ক:", Task.objects.all())
print("\nrafiq-এর টাস্কসমূহ:", Task.objects.filter(owner="rafiq"))

task_a.done = True
task_a.save()
print("\ntask_a সেভ করার পর, id দিয়ে আবার পড়া হলো:", Task.objects.filter(id=task_a.id))

# ========== মডিউল ৩: JWT-ভিত্তিক অথেন্টিকেশন (real HMAC-SHA256, M8/L34-এর পদ্ধতি পুনর্ব্যবহার) ==========
import hashlib, hmac, base64, json, time

JWT_SECRET = "capstone-super-secret-key"  # বাস্তবে env var/secrets manager-এ রাখা উচিত (L51)


def _b64url_encode(data):
    return base64.urlsafe_b64encode(data).rstrip(b"=").decode("ascii")


def _b64url_decode(s):
    padding = "=" * (-len(s) % 4)
    return base64.urlsafe_b64decode(s + padding)


def create_jwt(payload, secret=JWT_SECRET):
    header = {"alg": "HS256", "typ": "JWT"}
    header_b64 = _b64url_encode(json.dumps(header, separators=(",", ":")).encode())
    payload_b64 = _b64url_encode(json.dumps(payload, separators=(",", ":")).encode())
    signing_input = f"{header_b64}.{payload_b64}".encode()
    signature = hmac.new(secret.encode(), signing_input, hashlib.sha256).digest()
    signature_b64 = _b64url_encode(signature)
    return f"{header_b64}.{payload_b64}.{signature_b64}"


def verify_jwt(token, secret=JWT_SECRET):
    try:
        header_b64, payload_b64, signature_b64 = token.split(".")
    except ValueError:
        return None
    signing_input = f"{header_b64}.{payload_b64}".encode()
    expected_sig = hmac.new(secret.encode(), signing_input, hashlib.sha256).digest()
    expected_sig_b64 = _b64url_encode(expected_sig)
    if not hmac.compare_digest(expected_sig_b64, signature_b64):
        return None
    return json.loads(_b64url_decode(payload_b64))


# ---- JWT তৈরি ও সঠিক যাচাই ----
sample_token = create_jwt({"sub": "test_user", "iat": int(time.time())})
print("তৈরি হওয়া টোকেন:", sample_token)

verified_payload = verify_jwt(sample_token)
print("সঠিক টোকেন যাচাইয়ের ফলাফল:", verified_payload)
assert verified_payload is not None and verified_payload["sub"] == "test_user"

# ---- টেম্পারিং সিমুলেট করা: payload অংশের শেষ অক্ষর বদলে দেওয়া ----
header_b64, payload_b64, signature_b64 = sample_token.split(".")
tampered_last_char = "A" if payload_b64[-1] != "A" else "B"
tampered_payload_b64 = payload_b64[:-1] + tampered_last_char
tampered_token = f"{header_b64}.{tampered_payload_b64}.{signature_b64}"

tampered_result = verify_jwt(tampered_token)
print("\nটেম্পার করা টোকেন যাচাইয়ের ফলাফল:", tampered_result)
assert tampered_result is None, "টেম্পার করা টোকেন যাচাই ব্যর্থ হওয়া উচিত ছিল"
print("টেম্পার-শনাক্তকরণ কাজ করছে: স্বাক্ষর মিলছে না, তাই verify_jwt() None রিটার্ন করেছে।")

# ========== মডিউল ৪: ইউজার স্টোর, Router ও Auth মিডলওয়্যার ==========
import hashlib, time

USERS_DB = {}  # username থেকে {"username":.., "password_hash":..}

def hash_password(password):
    # সরলতার জন্য salt ছাড়া SHA-256 -- বাস্তব প্রোডাকশনে bcrypt/argon2/PBKDF2 ব্যবহার করা উচিত
    return hashlib.sha256(password.encode()).hexdigest()


class Router:
    def __init__(self):
        self.routes = {}

    def route(self, method, path):
        def decorator(handler_fn):
            self.routes[(method, path)] = handler_fn
            return handler_fn
        return decorator

    def dispatch(self, method, path, request=None):
        request = request or {}
        handler = self.routes.get((method, path))
        if handler is None:
            return {"status": 404, "body": {"error": "Not Found"}}
        return handler(request)


app = Router()


def auth_required(handler_fn):
    """মিডলওয়্যার -- Authorization হেডার থেকে JWT বের করে verify_jwt() দিয়ে যাচাই করে,
    তবেই আসল হ্যান্ডলার কল করে -- অন্যথায় হ্যান্ডলার পর্যন্ত পৌঁছানোর আগেই 401 রিটার্ন করে"""
    def wrapped(request):
        auth_header = request.get("headers", {}).get("Authorization", "")
        if not auth_header.startswith("Bearer "):
            return {"status": 401, "body": {"error": "Unauthorized -- টোকেন পাওয়া যায়নি"}}
        raw_token = auth_header[len("Bearer "):]
        payload = verify_jwt(raw_token)
        if payload is None:
            return {"status": 401, "body": {"error": "Unauthorized -- টোকেন অবৈধ বা টেম্পার করা"}}
        request["user"] = payload["sub"]
        return handler_fn(request)
    return wrapped


@app.route("POST", "/register")
def register(request):
    username = request["body"]["username"]
    password = request["body"]["password"]
    if username in USERS_DB:
        return {"status": 409, "body": {"error": "এই ইউজারনেম আগে থেকেই আছে"}}
    USERS_DB[username] = {"username": username, "password_hash": hash_password(password)}
    return {"status": 201, "body": {"username": username}}


@app.route("POST", "/login")
def login(request):
    username = request["body"]["username"]
    password = request["body"]["password"]
    user = USERS_DB.get(username)
    if user is None or user["password_hash"] != hash_password(password):
        return {"status": 401, "body": {"error": "ইউজারনেম বা পাসওয়ার্ড ভুল"}}
    token = create_jwt({"sub": username, "iat": int(time.time())})
    return {"status": 200, "body": {"token": token}}


@app.route("GET", "/tasks")
def list_tasks_route(request):
    tasks = [{"id": t.id, "title": t.title, "done": t.done, "owner": t.owner} for t in Task.objects.all()]
    return {"status": 200, "body": {"tasks": tasks}}


@app.route("POST", "/tasks")
@auth_required
def create_task_route(request):
    title = request["body"]["title"]
    task = Task.create(title=title, owner=request["user"])
    return {"status": 201, "body": {"task": {"id": task.id, "title": task.title, "done": task.done, "owner": task.owner}}}


print("রেজিস্টার করা রুটসমূহ:")
for method, path in app.routes:
    print(f"  {method:5s} {path}")

# ========== মডিউল ৫: ক্লায়েন্ট-সাইড Redux-স্টাইল স্টেট স্টোর ==========
def task_reducer(state, action):
    if action["type"] == "AUTH_SUCCESS":
        return {**state, "logged_in_user": action["payload"]["username"], "last_event": "AUTH_SUCCESS"}
    elif action["type"] == "TASK_CREATED":
        return {**state, "tasks": state["tasks"] + [action["payload"]], "last_event": "TASK_CREATED"}
    elif action["type"] == "TASK_REJECTED":
        return {**state, "last_event": "TASK_REJECTED", "last_error": action["payload"]}
    else:
        return state


class Store:
    def __init__(self, reducer, initial_state):
        self.reducer = reducer
        self.state = initial_state
        self._listeners = []

    def dispatch(self, action):
        self.state = self.reducer(self.state, action)
        for listener in self._listeners:
            listener(self.state)
        return self.state

    def subscribe(self, listener):
        self._listeners.append(listener)


def on_state_change(state):
    print(f"  [সাবস্ক্রাইবার] স্টেট পরিবর্তন হয়েছে, last_event={state.get('last_event')}")


client_store = Store(task_reducer, {"logged_in_user": None, "tasks": [], "last_event": None})
client_store.subscribe(on_state_change)

print("client_store-এর প্রাথমিক স্টেট:", client_store.state)

# ========== মডিউল ৬: সম্পূর্ণ এন্ড-টু-এন্ড ফ্লো ==========
print("=" * 70)
print("ধাপ (a): নতুন ইউজার রেজিস্টার করা")
resp_register = app.dispatch("POST", "/register", {"body": {"username": "rafiq", "password": "sEcr3t!23"}})
print(resp_register)
assert resp_register["status"] == 201

print("\n" + "=" * 70)
print("ধাপ (b): লগইন করে সত্যিকারের সাইন করা JWT পাওয়া")
resp_login = app.dispatch("POST", "/login", {"body": {"username": "rafiq", "password": "sEcr3t!23"}})
print(resp_login)
assert resp_login["status"] == 200
token = resp_login["body"]["token"]
print(f"প্রাপ্ত টোকেন: {token}")

client_store.dispatch({"type": "AUTH_SUCCESS", "payload": {"username": "rafiq"}})

print("\n" + "=" * 70)
print("ধাপ (c): টোকেন ছাড়া টাস্ক তৈরির চেষ্টা -- প্রত্যাখ্যাত হওয়া উচিত")
resp_no_token = app.dispatch("POST", "/tasks", {"headers": {}, "body": {"title": "প্রথম টাস্ক"}})
print(resp_no_token)
assert resp_no_token["status"] == 401, "টোকেন ছাড়া প্রোটেক্টেড রুট প্রত্যাখ্যান করা উচিত ছিল"

print("\n" + "=" * 70)
print("ধাপ (d): সঠিক টোকেন দিয়ে টাস্ক তৈরি -- সফল হওয়া উচিত")
resp_with_token = app.dispatch("POST", "/tasks", {"headers": {"Authorization": f"Bearer {token}"}, "body": {"title": "প্রথম টাস্ক"}})
print(resp_with_token)
assert resp_with_token["status"] == 201, "সঠিক টোকেন দিয়ে টাস্ক তৈরি সফল হওয়া উচিত ছিল"
created_task = resp_with_token["body"]["task"]

print("\n" + "=" * 70)
print("ধাপ (e): ক্লায়েন্ট Redux-স্টাইল স্টোরে TASK_CREATED অ্যাকশন dispatch করা")
old_state = client_store.state
client_store.dispatch({"type": "TASK_CREATED", "payload": created_task})
new_state = client_store.state
print(f"পুরনো স্টেট অবজেক্ট আইডি: {id(old_state)}")
print(f"নতুন স্টেট অবজেক্ট আইডি:  {id(new_state)}")
print(f"দুটো ভিন্ন অবজেক্ট (immutability বজায় আছে): {old_state is not new_state}")

print("\n" + "=" * 70)
print("ধাপ (f): চূড়ান্ত ক্লায়েন্ট-সাইড স্টেট")
print(client_store.state)
assert client_store.state["logged_in_user"] == "rafiq"
assert any(t["id"] == created_task["id"] for t in client_store.state["tasks"])
print("\nসারমর্ম: টোকেন ছাড়া 401, সঠিক টোকেনে 201, এবং নতুন টাস্কটি এখন ক্লায়েন্ট-স্টেটে সত্যিই উপস্থিত।")