#!/usr/bin/env python3
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

import sys
import json
import time
from requests_oauthlib import OAuth1Session


def fail(message):
    print(json.dumps({"error": message}))
    sys.exit(1)


def succeed(data):
    print(json.dumps(data))
    sys.exit(0)


class MaasManager:
    def __init__(self, config_path):
        self.config_path = config_path
        self.data = self.parse_json()
        self.session = self.init_session()

    def parse_json(self):
        try:
            with open(self.config_path, "r") as f:
                json_data = json.load(f)

            extension = json_data.get("externaldetails", {}).get("extension", {})
            host = json_data.get("externaldetails", {}).get("host", {})
            vm = json_data.get("externaldetails", {}).get("virtualmachine", {})

            endpoint = host.get("endpoint") or extension.get("endpoint")
            apikey = host.get("apikey") or extension.get("apikey")

            details = json_data.get("cloudstack.vm.details", {}).get("details", {})

            os_name = details.get("os") or vm.get("os")
            architecture = details.get("architecture") or vm.get("architecture")
            distro_series = details.get("distro_series") or vm.get("distro_series")

            if not endpoint or not apikey:
                fail("Missing MAAS endpoint or apikey")

            if not endpoint.startswith("http://") and not endpoint.startswith("https://"):
                endpoint = "http://" + endpoint
            endpoint = endpoint.rstrip("/")

            parts = apikey.split(":")
            if len(parts) != 3:
                fail("Invalid apikey format. Expected consumer:token:secret")

            consumer, token, secret = parts

            system_id = details.get("maas_system_id") or vm.get("maas_system_id", "")

            vm_name = vm.get("vm_name") or json_data.get("cloudstack.vm.details", {}).get("name")
            if not vm_name:
                vm_name = f"cs-{system_id}" if system_id else "cs-unknown"

            return {
                "endpoint": endpoint,
                "consumer": consumer,
                "token": token,
                "secret": secret,
                "distro_series": distro_series or "ubuntu/focal",
                "os": os_name,
                "architecture": architecture,
                "system_id": system_id,
                "vm_name": vm_name,
            }
        except Exception as e:
            fail(f"Error parsing JSON: {str(e)}")

    def init_session(self):
        return OAuth1Session(
            self.data["consumer"],
            resource_owner_key=self.data["token"],
            resource_owner_secret=self.data["secret"],
        )

    def call_maas(self, method, path, data=None, ignore_404=False):
        if not path.startswith("/"):
            path = "/" + path
        url = f"{self.data['endpoint']}:5240/MAAS/api/2.0{path}"
        resp = self.session.request(method, url, data=data)

        if resp.status_code == 404 and ignore_404:
            return None

        if not resp.ok:
            fail(f"MAAS API error: {resp.status_code} {resp.text}")

        try:
            return resp.json() if resp.text else {}
        except ValueError:
            return {}

    def prepare(self):
        machines = self.call_maas("GET", "/machines/")
        ready = [m for m in machines if m.get("status_name") == "Ready"]
        if not ready:
            fail("No Ready machines available")

        sysid = self.data.get("system_id")

        if sysid:
            match = next((m for m in ready if m["system_id"] == sysid), None)
            if not match:
                fail(f"Provided system_id '{sysid}' not found among Ready machines")
            system = match
        else:
            system = ready[0]

        system_id = system["system_id"]
        mac = system.get("interface_set", [{}])[0].get("mac_address")
        hostname = system.get("hostname", "")

        if not mac:
            fail("No MAC address found")

        # Load original JSON so we can update nics
        with open(self.config_path, "r") as f:
            json_data = json.load(f)

        if json_data.get("cloudstack.vm.details", {}).get("nics"):
            json_data["cloudstack.vm.details"]["nics"][0]["mac"] = mac

        console_url = f"http://{self.data['endpoint'].replace('http://','').replace('https://','')}:5240/MAAS/r/machine/{system_id}/summary"

        result = {
            "nics": json_data["cloudstack.vm.details"]["nics"],
            "details": {
                "External:mac_address": mac,
                "External:maas_system_id": system_id,
                "External:hostname": hostname,
                "External:console_url": console_url,
            },
        }
        succeed(result)

    def create(self):
        sysid = self.data.get("system_id")
        if not sysid:
            fail("system_id missing for create")

        ds = self.data.get("distro_series", None)
        os_name = self.data.get("os")
        arch = self.data.get("architecture")

        deploy_payload = {"op": "deploy"}

        if os_name or arch:
            if os_name:
                deploy_payload["os"] = os_name
            if arch:
                deploy_payload["architecture"] = arch
            if ds:
                deploy_payload["distro_series"] = ds
        else:
            deploy_payload["distro_series"] = ds or "ubuntu/focal"

        deploy_payload["net-setup-method"] = "curtin"

        self.call_maas("POST", f"/machines/{sysid}/", deploy_payload)

        succeed({"status": "success", "message": "Instance created", "requested": deploy_payload})

    def delete(self):
        sysid = self.data.get("system_id")
        if not sysid:
            fail("system_id missing for delete")

        self.call_maas("POST", f"/machines/{sysid}/", {"op": "release"}, ignore_404=True)
        succeed({"status": "success", "message": f"Instance deleted or not found ({sysid})"})

    def start(self):
        sysid = self.data.get("system_id")
        if not sysid:
            fail("system_id missing for start")
        self.call_maas("POST", f"/machines/{sysid}/", {"op": "power_on"})
        succeed({"status": "success", "power_state": "PowerOn"})

    def stop(self):
        sysid = self.data.get("system_id")
        if not sysid:
            fail("system_id missing for stop")
        self.call_maas("POST", f"/machines/{sysid}/", {"op": "power_off"})
        succeed({"status": "success", "power_state": "PowerOff"})

    def reboot(self):
        sysid = self.data.get("system_id")
        if not sysid:
            fail("system_id missing for reboot")

        self.call_maas("POST", f"/machines/{sysid}/", {"op": "power_off"})
        time.sleep(5)
        self.call_maas("POST", f"/machines/{sysid}/", {"op": "power_on"})

        succeed({"status": "success", "power_state": "PowerOn", "message": "Reboot completed"})

    def status(self):
        sysid = self.data.get("system_id")
        if not sysid:
            fail("system_id missing for status")
        resp = self.call_maas("GET", f"/machines/{sysid}/")
        state = resp.get("power_state", "")
        if state == "on":
            mapped = "PowerOn"
        elif state == "off":
            mapped = "PowerOff"
        else:
            mapped = "PowerUnknown"
        succeed({"status": "success", "power_state": mapped})


def main():
    if len(sys.argv) < 3:
        fail("Usage: maas.py <action> <json-file-path>")

    action = sys.argv[1].lower()
    json_file = sys.argv[2]

    try:
        manager = MaasManager(json_file)
    except FileNotFoundError:
        fail(f"JSON file not found: {json_file}")

    actions = {
        "prepare": manager.prepare,
        "create": manager.create,
        "delete": manager.delete,
        "start": manager.start,
        "stop": manager.stop,
        "reboot": manager.reboot,
        "status": manager.status,
    }

    if action not in actions:
        fail("Invalid action")

    actions[action]()


if __name__ == "__main__":
    main()