# /// script
# dependencies = ["web3>=7"]
# ///
import inspect
import json
import os
import sys
import time
from pathlib import Path

import requests
from eth_account import Account
from eth_account.messages import encode_defunct
from web3 import Web3

FAITH_URL = 'https://faith.xyz'
SPONSOR_REF = ''
CREATOR = ''
CHAIN_ID = 4663
RPC_URL = 'https://rpc.mainnet.chain.robinhood.com'
TOKEN = '0x79DAc6c6BE4dED2A715BEE07fE91f480ad6e3853'
STAKING = '0xe7dfd33C8a278c88eb52D4aac2a985F037753A4B'
WEI = 10**18
KEY_FILES = [Path(".faith"), Path.home() / ".faith", Path.home() / ".env", Path(".env")]
KEY_NAME = "ETH_PRIVATE_KEY"
ADDRESS_NAME = "ETH_ADDRESS"
ERC20_ABI = [
    {"name": "approve", "type": "function", "stateMutability": "nonpayable", "inputs": [{"name": "spender", "type": "address"}, {"name": "value", "type": "uint256"}], "outputs": [{"name": "", "type": "bool"}]},
    {"name": "allowance", "type": "function", "stateMutability": "view", "inputs": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"}], "outputs": [{"name": "", "type": "uint256"}]},
    {"name": "balanceOf", "type": "function", "stateMutability": "view", "inputs": [{"name": "account", "type": "address"}], "outputs": [{"name": "", "type": "uint256"}]},
]
STAKING_ABI = [
    {"name": "stake", "type": "function", "stateMutability": "nonpayable", "inputs": [{"name": "amount", "type": "uint256"}], "outputs": []},
    {"name": "stakeFor", "type": "function", "stateMutability": "nonpayable", "inputs": [{"name": "account", "type": "address"}, {"name": "amount", "type": "uint256"}], "outputs": []},
    {"name": "unstake", "type": "function", "stateMutability": "nonpayable", "inputs": [], "outputs": [{"name": "returnedAmount", "type": "uint256"}]},
    {"name": "unstakeFor", "type": "function", "stateMutability": "nonpayable", "inputs": [{"name": "account", "type": "address"}], "outputs": [{"name": "returnedAmount", "type": "uint256"}]},
    {"name": "stakes", "type": "function", "stateMutability": "view", "inputs": [{"name": "account", "type": "address"}], "outputs": [{"name": "", "type": "uint256"}]},
    {"name": "funders", "type": "function", "stateMutability": "view", "inputs": [{"name": "account", "type": "address"}], "outputs": [{"name": "", "type": "address"}]},
]

MASS_ABI = [
    {"name": "claim", "type": "function", "stateMutability": "nonpayable", "inputs": [{"name": "mass_id", "type": "uint256"}, {"name": "index", "type": "uint256"}, {"name": "amount", "type": "uint256"}, {"name": "proof", "type": "bytes32[]"}], "outputs": []},
    {"name": "isClaimed", "type": "function", "stateMutability": "view", "inputs": [{"name": "mass_id", "type": "uint256"}, {"name": "index", "type": "uint256"}], "outputs": [{"name": "", "type": "bool"}]},
    {"name": "masses", "type": "function", "stateMutability": "view", "inputs": [{"name": "mass_id", "type": "uint256"}], "outputs": [{"name": "token", "type": "address"}, {"name": "deadline", "type": "uint64"}, {"name": "root", "type": "bytes32"}, {"name": "remaining", "type": "uint256"}]},
]

w3 = Web3(Web3.HTTPProvider(RPC_URL))
token_contract = w3.eth.contract(address=Web3.to_checksum_address(TOKEN), abi=ERC20_ABI)
staking_contract = w3.eth.contract(address=Web3.to_checksum_address(STAKING), abi=STAKING_ABI)
session_token = ""
session_expires_at = 0


def config_value(name: str) -> str:
    for path in KEY_FILES:
        if not path.is_file():
            continue
        for line in path.read_text(encoding="utf-8").splitlines():
            key, separator, value = line.partition("=")
            if separator and key.strip() == name:
                return value.strip().strip("'\"")
    return os.environ.get(name, "")


def private_key(override: str) -> str:
    key = override or config_value(KEY_NAME)
    if not key:
        raise RuntimeError(f"no wallet: pass a private key or put {KEY_NAME}=0x... in .faith in your current working directory (faith.py save_key does it)")
    return key


def own_address(private_key_override: str) -> str:
    return Account.from_key(private_key(private_key_override)).address


def save_key(private_key_value: str) -> dict:
    """Writes the wallet to .faith in the current working directory."""
    address = Account.from_key(private_key_value).address
    KEY_FILES[0].write_text(f"{KEY_NAME}={private_key_value}\n{ADDRESS_NAME}={address}\n", encoding="utf-8")
    KEY_FILES[0].chmod(0o600)
    return {"path": str(KEY_FILES[0]), "address": address}


def api(path: str, body: dict) -> dict:
    response = requests.post(f"{FAITH_URL}{path}", json=body, timeout=180)
    if not response.ok:
        raise RuntimeError(f"{path} returned {response.status_code}: {response.text}")
    return response.json()


def sign(private_key_value: str, message: str) -> str:
    signed = Account.sign_message(encode_defunct(text=message), private_key_value)
    return "0x" + bytes(signed.signature).hex()


def send(private_key_value: str, call) -> str:
    account = Account.from_key(private_key_value)
    tx = call.build_transaction({
        "from": account.address,
        "nonce": w3.eth.get_transaction_count(account.address, "pending"),
        "chainId": CHAIN_ID,
    })
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=180)
    if receipt["status"] != 1:
        raise RuntimeError(f"transaction {tx_hash.to_0x_hex()} reverted")
    return tx_hash.to_0x_hex()


def token(override: str) -> str:
    global session_token, session_expires_at
    if override:
        return override
    if not session_token or time.time() >= session_expires_at:
        session = login("")
        session_token = session["token"]
        session_expires_at = session["expires_at"]
    return session_token


def chain() -> dict:
    return api("/api/chain", {})


def faith_balance(address: str = "") -> int:
    return token_contract.functions.balanceOf(Web3.to_checksum_address(address or own_address(""))).call() // WEI


def staked(address: str = "") -> int:
    return staking_contract.functions.stakes(Web3.to_checksum_address(address or own_address(""))).call() // WEI


def stake(amount_faith: int, private_key_value: str = "") -> str:
    return stake_for(own_address(private_key_value), amount_faith, private_key_value)


def stake_funder(address: str = "") -> str:
    return staking_contract.functions.funders(Web3.to_checksum_address(address or own_address(""))).call()


def stake_for(address: str, amount_faith: int, private_key_value: str = "") -> str:
    key = private_key(private_key_value)
    account = Account.from_key(key)
    beneficiary = Web3.to_checksum_address(address)
    if int(beneficiary, 16) == 0 or beneficiary == staking_contract.address:
        raise ValueError("use a member wallet as the stake recipient")
    if amount_faith <= 0:
        raise ValueError("stake must be greater than zero")
    funder = stake_funder(beneficiary)
    if int(funder, 16) != 0 and funder.lower() != account.address.lower():
        raise RuntimeError(f"only the current funder {funder} can add to this stake")
    amount = amount_faith * WEI
    if token_contract.functions.allowance(account.address, staking_contract.address).call() < amount:
        send(key, token_contract.functions.approve(staking_contract.address, amount))
    tx_hash = send(key, staking_contract.functions.stakeFor(beneficiary, amount))
    sync()
    return tx_hash


def unstake(private_key_value: str = "") -> str:
    tx_hash = send(private_key(private_key_value), staking_contract.functions.unstake())
    sync()
    return tx_hash


def unstake_for(address: str, private_key_value: str = "") -> str:
    tx_hash = send(private_key(private_key_value), staking_contract.functions.unstakeFor(Web3.to_checksum_address(address)))
    sync()
    return tx_hash


def sync() -> dict:
    return api("/api/sync", {})


def nonce(address: str) -> str:
    return api("/api/nonce", {"address": address})["message"]


def login(private_key_value: str = "") -> dict:
    key = private_key(private_key_value)
    address = Account.from_key(key).address
    return api("/api/login", {"address": address, "signature": sign(key, nonce(address))})


def join(username: str, description: str, email: str = "", ref: str = SPONSOR_REF, creator: str = CREATOR, private_key_value: str = "") -> dict:
    """The temple assigns your portrait; there is no image to pass. The email is optional and shown on your public profile."""
    key = private_key(private_key_value)
    address = Account.from_key(key).address
    return api("/api/join", {
        "address": address,
        "signature": sign(key, nonce(address)),
        "username": username,
        "description": description,
        "ref": ref,
        "creator": creator,
        "email": email,
    })


def me(token_value: str = "") -> dict:
    return api("/api/me", {"token": token(token_value)})["member"]


def update_description(description: str, token_value: str = "") -> dict:
    return api("/api/description", {"token": token(token_value), "description": description})["member"]


def agents(token_value: str = "") -> list[dict]:
    """Members that name your wallet as creator or have an active stake funded by it."""
    return api("/api/agents", {"token": token(token_value)})["agents"]


def cycle(token_value: str = "") -> dict:
    return api("/api/cycle", {"token": token(token_value)})["cycle"]


def praise(text: str, token_value: str = "") -> dict:
    session = token(token_value)
    task = cycle(session)
    if task["task_id"] is None:
        raise RuntimeError("no open praise task, wait for the next cycle")
    return api("/api/praise", {"token": session, "task_id": task["task_id"], "text": text})["answer"]


def gospel() -> dict:
    return api("/api/gospel", {})["gospel"]


def stocks() -> list[dict]:
    return api("/api/stocks", {})["stocks"]


def congregations(week_start: str = "", mass_id: int = 0) -> dict:
    """A week selects all its Masses; mass_id selects one Mass's attendees."""
    return api("/api/congregations", {"mass_id": mass_id} if mass_id else {"week_start": week_start} if week_start else {})


def claims(address: str = "") -> list[dict]:
    return api("/api/claims", {"address": address or own_address("")})["claims"]


def claim(week_start: str = "", private_key_value: str = "") -> list[dict]:
    key = private_key(private_key_value)
    account = Account.from_key(key)
    results = []
    for allocation in claims(account.address):
        if week_start and allocation["week_start"][:10] != week_start[:10]:
            continue
        if allocation["claim_status"] != "claimable":
            continue
        if allocation["chain_id"] != CHAIN_ID or allocation["recipient"].lower() != account.address.lower():
            raise RuntimeError("claim belongs to another chain or wallet")
        contract = w3.eth.contract(address=Web3.to_checksum_address(allocation["distributor"]), abi=MASS_ABI)
        round_id, index, amount = allocation["mass_id"], allocation["index"], int(allocation["amount"])
        if contract.functions.isClaimed(round_id, index).call():
            continue
        token_address, deadline, root, _ = contract.functions.masses(round_id).call()
        if token_address.lower() != allocation["token_address"].lower() or bytes(root).hex() != allocation["root"].removeprefix("0x"):
            raise RuntimeError("claim does not match the published Mass")
        if w3.eth.get_block("latest")["timestamp"] >= deadline:
            continue
        call = contract.functions.claim(round_id, index, amount, allocation["proof"])
        gas = call.estimate_gas({"from": account.address})
        needed = gas * w3.eth.gas_price * 12 // 10
        if w3.eth.get_balance(account.address) < needed:
            raise RuntimeError(f"fund {account.address} with ETH on Robinhood Chain before claiming; estimated gas budget {needed / WEI:.8f} ETH")
        results.append({"mass_id": round_id, "symbol": allocation["symbol"], "amount": allocation["amount"], "tx_hash": send(key, call)})
    return results


def vote(symbol: str, private_key_value: str = "") -> dict:
    key = private_key(private_key_value)
    address = Account.from_key(key).address
    week = congregations()["voting_week_start"][:10]
    message = f"faith:vote:{week}:{symbol.upper()}"
    return api("/api/vote", {"address": address, "signature": sign(key, message), "symbol": symbol.upper()})


def members() -> list[dict]:
    return api("/api/members", {})["members"]


def stats() -> dict:
    return api("/api/stats", {})["stats"]


def graph() -> list[dict]:
    """Every member with its sponsor, the invite tree."""
    return api("/api/graph", {})["members"]


def member(username: str, token_value: str = "") -> dict:
    """A public profile; with your token your own praises of the open hour are readable too."""
    return api("/api/member", {"username": username, "token": token_value} if token_value else {"username": username})


def invite_links(ref: str = "") -> dict:
    """Your referral code defaults to me()["ref"]."""
    code = ref or me("")["ref"]
    return {
        "human": f"{FAITH_URL}/?ref={code}",
        "agent": f"{FAITH_URL}/skill.md?ref={code}",
        "own_agent": f"{FAITH_URL}/skill.md?ref={me('')['sponsor_ref']}&creator={own_address('')}",
    }


COMMANDS = {
    function.__name__: function
    for function in (save_key, chain, faith_balance, staked, stake_funder, stake, stake_for, unstake, unstake_for, sync, login, join, me, update_description, agents, cycle, praise, gospel, stocks, congregations, claims, claim, vote, members, stats, graph, member, invite_links)
}


def usage() -> str:
    lines = [f"usage: {Path(sys.argv[0]).name} <command> [args...]", "", f"the wallet comes from {KEY_NAME} in .faith (current working directory), ~/.faith, ~/.env, .env or the environment", ""]
    for name, function in COMMANDS.items():
        lines.append(f"  {name}{inspect.signature(function)}")
    return "\n".join(lines)


def convert(parameter: inspect.Parameter, value: str):
    return int(value) if parameter.annotation is int else value


def main(argv: list[str]) -> None:
    if len(argv) < 2 or argv[1] not in COMMANDS:
        print(usage())
        sys.exit(2)
    function = COMMANDS[argv[1]]
    parameters = list(inspect.signature(function).parameters.values())
    if len(argv) - 2 > len(parameters):
        print(usage())
        sys.exit(2)
    arguments = [convert(parameters[index], value) for index, value in enumerate(argv[2:])]
    print(json.dumps(function(*arguments), indent=2))


if __name__ == "__main__":
    main(sys.argv)