Update Twins

from typing import List

from iotics.lib.identity.api.high_level_api import get_rest_high_level_identity_api
from requests import request

RESOLVER_URL = "resolver_url"
HOST = "host_url"

USER_KEY_NAME = "user_key_name"
AGENT_KEY_NAME = "agent_key_name"
USER_SEED = bytes.fromhex("user_seed")
AGENT_SEED = bytes.fromhex("agent_seed")


class IoticsRest:
    def __init__(self):
        self._high_level_api = get_rest_high_level_identity_api(
            resolver_url=RESOLVER_URL
        )

        (
            self._user_registered_id,
            self._agent_registered_id,
        ) = self._high_level_api.create_user_and_agent_with_auth_delegation(
            user_seed=USER_SEED,
            user_key_name=USER_KEY_NAME,
            agent_seed=AGENT_SEED,
            agent_key_name=AGENT_KEY_NAME,
            delegation_name="#AuthDeleg",
        )

        token = self._high_level_api.create_agent_auth_token(
            agent_registered_identity=self._agent_registered_id,
            user_did=self._user_registered_id.did,
            duration=10,
        )

        self._headers = {
            "accept": "application/json",
            "Iotics-ClientAppId": "example_code",
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        }

    def _make_api_call(self, method: str, url: str, json: dict = None):
        response = request(method=method, url=url, headers=self._headers, json=json)
        response.raise_for_status()

        return response.json()

    def create_twin_identity(self, twin_key_name: str):
        twin_registered_id = self._high_level_api.create_twin_with_control_delegation(
            twin_seed=AGENT_SEED,
            twin_key_name=twin_key_name,
            agent_registered_identity=self._agent_registered_id,
            delegation_name="#ControlDeleg",
        )

        return twin_registered_id.did

    def create_twin(self, twin_did: str):
        twin = self._make_api_call(
            method="POST", url=f"{HOST}/qapi/twins", json={"id": twin_did}
        )

        return twin

    def create_feed(self, twin_did: str, host_id: str, feed_id: str):
        feed = self._make_api_call(
            method="POST",
            url=f"{HOST}/qapi/hosts/{host_id}/twins/{twin_did}/feeds",
            json={"id": feed_id},
        )

        return feed

    def update_twin(
        self,
        twin_did: str,
        host_id: str,
        location: dict = None,
        properties_to_add: List[dict] = [],
        properties_to_remove: List[str] = [],
        delete_all_properties: bool = False,
    ):
        payload = {}

        if location:
            payload["location"] = location
        if properties_to_add:
            payload["properties"] = {"added": properties_to_add}
        if properties_to_remove:
            payload["properties"] = {"deletedByKey": properties_to_remove}
        if delete_all_properties:
            payload["properties"] = {"clearedAll": True}

        self._make_api_call(
            method="PATCH",
            url=f"{HOST}/qapi/hosts/{host_id}/twins/{twin_did}",
            json=payload,
        )

    def update_feed(
        self,
        twin_did: str,
        host_id: str,
        feed_id: str,
        properties_to_add: List[dict] = [],
        properties_to_remove: List[str] = [],
        delete_all_properties: bool = False,
        values_metadata: List[dict] = None,
        store_last=True,
    ):
        payload = {"storeLast": store_last}

        if properties_to_add:
            payload["properties"] = {"added": properties_to_add}
        if properties_to_remove:
            payload["properties"] = {"deletedByKey": properties_to_remove}
        if delete_all_properties:
            payload["properties"] = {"clearedAll": True}

        if values_metadata:
            payload["values"] = {"added": values_metadata}

        self._make_api_call(
            method="PATCH",
            url=f"{HOST}/qapi/hosts/{host_id}/twins/{twin_did}/feeds/{feed_id}",
            json=payload,
        )


def main():
    iotics_rest = IoticsRest()
    twin_did = iotics_rest.create_twin_identity(twin_key_name="SensorTwin")
    twin = iotics_rest.create_twin(twin_did=twin_did)
    host_id = twin["twinId"]["hostId"]
    iotics_rest.update_twin(
        twin_did=twin_did,
        host_id=host_id,
        properties_to_add=[
            # Add a Label
            {
                "key": "http://www.w3.org/2000/01/rdf-schema#label",
                "langLiteralValue": {"value": "Temperature Sensor", "lang": "en"},
            },
            # Add a comment
            {
                "key": "http://www.w3.org/2000/01/rdf-schema#comment",
                "langLiteralValue": {
                    "value": "A temperature sensor that shares temperature data",
                    "lang": "en",
                },
            },
        ],
        location={"location": {"lat": 51.5, "lon": -0.1}},
    )
    iotics_rest.create_feed(twin_did=twin_did, host_id=host_id, feed_id="temperature")
    iotics_rest.update_feed(
        twin_did=twin_did,
        host_id=host_id,
        feed_id="temperature",
        properties_to_add=[
            # Add a Label
            {
                "key": "http://www.w3.org/2000/01/rdf-schema#label",
                "langLiteralValue": {"value": "Current Temperature", "lang": "en"},
            },
            # Add a comment
            {
                "key": "http://www.w3.org/2000/01/rdf-schema#comment",
                "langLiteralValue": {
                    "value": "The current temperature reading",
                    "lang": "en",
                },
            },
        ],
        # Add Value's metadata
        values_metadata=[
            {
                "comment": "Temperature in degrees Celsius",
                "dataType": "decimal",
                "label": "reading",
                "unit": "http://qudt.org/vocab/unit/DEG_C",
            }
        ],
    )


if __name__ == "__main__":
    main()