# 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.
""" BVT tests for custom extension
"""
# Import Local Modules
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.cloudstackAPI import listManagementServers
from marvin.lib.base import (Extension,
                             Pod,
                             Cluster,
                             Host,
                             Template,
                             ServiceOffering,
                             NetworkOffering,
                             Network,
                             VirtualMachine,
                             ExtensionCustomAction)
from marvin.lib.common import (get_zone)
from marvin.lib.utils import (random_gen)
from marvin.sshClient import SshClient
from nose.plugins.attrib import attr
# Import System modules
import json
import logging
from pathlib import Path
import random
import string
import time

_multiprocess_shared_ = True

CUSTOM_EXTENSION_CONTENT = """#!/bin/bash

parse_json() {
  local json_string=$1
  echo "$json_string" | jq '.' > /dev/null || { echo '{"error":"Invalid JSON input"}'; exit 1; }
}

get_vm_name() {
  local input_json=$1
  local name
  name=$(jq -r '.virtualmachinename' <<< "$input_json")
  if [[ -z "$name" || "$name" == "null" ]]; then
      echo '{"status":"error","message":"virtualmachinename missing in JSON"}'
      exit 1
  fi
  echo "$name"
}

get_vm_file() {
  local name=$1
  local script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
  echo "$script_dir/$name"
}

validate_vm_file_exists() {
  local file=$1
  if [[ ! -f "$file" ]]; then
      echo '{"status":"error","message":"Instance file not found"}'
      exit 1
  fi
}

update_vm_status() {
  local file=$1
  local status=$2
  local updated_json
  updated_json=$(jq --arg status "$status" '.status = $status' "$file")
  echo "$updated_json" > "$file"
}

prepare() {
  echo ""
}

create() {
  parse_json "$1"
  local vm_name updated_json file
  vm_name=$(get_vm_name "$1")
  file=$(get_vm_file "$vm_name")

  updated_json=$(jq '. + {status: "Running"}' <<< "$1")
  echo "$updated_json" > "$file"

  jq -n --arg file "$file" \
      '{status: "success", message: "Instance created", file: $file}'
}

delete() {
  parse_json "$1"
  local vm_name file
  vm_name=$(get_vm_name "$1")
  file=$(get_vm_file "$vm_name")

  if [[ -f "$file" ]]; then
      rm -f "$file"
  fi
  jq -n --arg file "$file" \
      '{status: "success", message: "Instance deleted", file: $file}'
}

start() {
  parse_json "$1"
  local vm_name file
  vm_name=$(get_vm_name "$1")
  file=$(get_vm_file "$vm_name")
  validate_vm_file_exists "$file"

  update_vm_status "$file" "Running"
  echo '{"status": "success", "message": "Instance started"}'
}

stop() {
  parse_json "$1"
  local vm_name file
  vm_name=$(get_vm_name "$1")
  file=$(get_vm_file "$vm_name")

  if [[ -f "$file" ]]; then
      update_vm_status "$file" "Stopped"
  fi
  echo '{"status": "success", "message": "Instance stopped"}'
}

reboot() {
  parse_json "$1"
  local vm_name file
  vm_name=$(get_vm_name "$1")
  file=$(get_vm_file "$vm_name")
  validate_vm_file_exists "$file"

  update_vm_status "$file" "Running"
  echo '{"status": "success", "message": "Instance rebooted"}'
}

status() {
  parse_json "$1"
  local vm_name file vm_status
  vm_name=$(get_vm_name "$1")
  file=$(get_vm_file "$vm_name")
  validate_vm_file_exists "$file"

  vm_status=$(jq -r '.status' "$file")
  [[ -z "$vm_status" || "$vm_status" == "null" ]] && vm_status="unknown"

  case "${vm_status,,}" in
    "running"|"poweron")
      power_state="PowerOn"
      ;;
    "stopped"|"shutdown"|"poweroff")
      power_state="PowerOff"
      ;;
    *)
      power_state="$vm_status"
      ;;
  esac

  jq -n --arg ps "$power_state" '{status: "success", power_state: $ps}'
}

testaction() {
  parse_json "$1"
  local vm_name param_val
  vm_name=$(get_vm_name "$1")
  param_val=$(jq -r '.parameters.Name' <<< "$1")

  echo "$param_val for $vm_name"
}

action=$1
parameters_file="$2"
wait_time="$3"

if [[ -z "$action" || -z "$parameters_file" ]]; then
  echo '{"error":"Missing required arguments"}'
  exit 1
fi

if [[ ! -r "$parameters_file" ]]; then
  echo '{"error":"File not found or unreadable"}'
  exit 1
fi

parameters=$(<"$parameters_file")

case $action in
  prepare)     prepare "$parameters" ;;
  create)      create "$parameters" ;;
  delete)      delete "$parameters" ;;
  start)       start "$parameters" ;;
  stop)        stop "$parameters" ;;
  reboot)      reboot "$parameters" ;;
  status)      status "$parameters" ;;
  testaction)  testaction "$parameters" ;;
  *)           echo '{"error":"Invalid action"}'; exit 1 ;;
esac

exit 0

"""

class TestExtensions(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):
        testClient = super(TestExtensions, cls).getClsTestClient()
        cls.apiclient = testClient.getApiClient()
        cls.services = testClient.getParsedTestDataConfig()

        # Get Zone
        cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())

        cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__

        cls._cleanup = []
        cls.logger = logging.getLogger('TestExtensions')
        cls.logger.setLevel(logging.DEBUG)

        cls.compute_offering = ServiceOffering.create(
            cls.apiclient,
            cls.services["service_offerings"]["tiny"])
        cls._cleanup.append(cls.compute_offering)
        cls.network_offering = NetworkOffering.create(
            cls.apiclient,
            cls.services["l2-network_offering"],
        )
        cls._cleanup.append(cls.network_offering)
        cls.network_offering.update(cls.apiclient, state='Enabled')
        cls.services["network"]["networkoffering"] = cls.network_offering.id
        cls.l2_network = Network.create(
            cls.apiclient,
            cls.services["l2-network"],
            zoneid=cls.zone.id,
            networkofferingid=cls.network_offering.id
        )
        cls._cleanup.append(cls.l2_network)

        cls.resource_name_suffix = random_gen()
        cls.create_cluster()
        cls.extension = Extension.create(
            cls.apiclient,
            name=f"ext-{cls.resource_name_suffix}",
            type='Orchestrator'
        )
        cls._cleanup.append(cls.extension)
        cls.update_extension_path(cls.extension.path)
        cls.extension.register(cls.apiclient, cls.cluster.id, 'Cluster')
        details = {
            'url': f"host-{cls.resource_name_suffix}",
            'zoneid': cls.cluster.zoneid,
            'podid': cls.cluster.podid,
            'username': 'External',
            'password': 'External'
        }
        cls.host = Host.create(
            cls.apiclient,
            cls.cluster,
            details,
            hypervisor=cls.cluster.hypervisortype
        )
        cls._cleanup.append(cls.host)
        template_name = f"template-{cls.resource_name_suffix}"
        template_data = {
            "name": template_name,
            "displaytext": template_name,
            "format": cls.host.hypervisor,
            "hypervisor": cls.host.hypervisor,
            "ostype": "Other Linux (64-bit)",
            "url": template_name,
            "requireshvm": "True",
            "ispublic": "True",
            "isextractable": "True",
            "extensionid": cls.extension.id
        }
        cls.template = Template.register(
            cls.apiclient,
            template_data,
            zoneid=cls.zone.id,
            hypervisor=cls.cluster.hypervisortype
        )
        cls._cleanup.append(cls.template)
        logging.info("Waiting for 3 seconds for template to be ready")
        time.sleep(3)
        cls.services["virtual_machine"]["zoneid"] = cls.zone.id
        cls.services["virtual_machine"]["template"] = cls.template.id

    @classmethod
    def tearDownClass(cls):
        super(TestExtensions, cls).tearDownClass()

    @classmethod
    def create_cluster(cls):
        pod_list = Pod.list(cls.apiclient)
        if len(pod_list) <= 0:
            cls.fail("No Pods found")
        pod_id = pod_list[0].id
        cluster_services = {
            'clustername': 'cluster-' + cls.resource_name_suffix,
            'clustertype': 'CloudManaged'
        }
        cls.cluster = Cluster.create(
            cls.apiclient,
            cluster_services,
            cls.zone.id,
            pod_id,
            'External'
        )
        cls._cleanup.append(cls.cluster)

    @classmethod
    def getManagementServerIps(cls):
        if cls.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'):
            return None
        cmd = listManagementServers.listManagementServersCmd()
        servers = cls.apiclient.listManagementServers(cmd)
        active_server_ips = []
        active_server_ips.append(cls.mgtSvrDetails["mgtSvrIp"])
        for idx, server in enumerate(servers):
            if server.state == 'Up' and server.ipaddress != cls.mgtSvrDetails["mgtSvrIp"]:
                active_server_ips.append(server.ipaddress)
        return active_server_ips

    @classmethod
    def update_path_locally(cls, path):
        try:
            file = Path(path)
            file.write_text(CUSTOM_EXTENSION_CONTENT)
            file.chmod(file.stat().st_mode | 0o111)  # Make executable
        except Exception as e:
            cls.fail(f"Failed to update path on localhost: {str(e)}")

    @classmethod
    def update_extension_path(cls, path):
        logging.info(f"Updating extension path {path}")
        server_ips = cls.getManagementServerIps()
        if server_ips is None:
            if cls.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'):
                cls.update_path_locally(path)
                return
            cls.fail(f"Extension path update cannot be done on {cls.mgtSvrDetails['mgtSvrIp']}")
        logging.info("Updating extension path on all management server")
        command = (
            f"cat << 'EOF' > {path}\n{CUSTOM_EXTENSION_CONTENT}\nEOF\n"
            f"chmod +x {path}"
        )
        for idx, server_ip in enumerate(server_ips):
            logging.info(f"Updating extension path on management server #{idx} with IP {server_ip}")
            sshClient = SshClient(
                server_ip,
                22,
                cls.mgtSvrDetails["user"],
                cls.mgtSvrDetails["passwd"]
            )
            sshClient.execute(command)

    def setUp(self):
        self.cleanup = []

    def tearDown(self):
        super(TestExtensions, self).tearDown()

    def get_vm_content_path(self, extension_path, vm_name):
        directory = extension_path.rsplit('/', 1)[0] if '/' in extension_path else '.'
        path = f"{directory}/{vm_name}"
        return path

    def get_vm_content_locally(self, path):
        try:
            file = Path(path)
            if not file.exists():
                return None
            return file.read_text().strip()
        except Exception:
            return None

    def get_vm_content(self, extension_path, vm_name):
        path = self.get_vm_content_path(extension_path, vm_name)
        server_ips = self.getManagementServerIps()
        if not server_ips:
            if self.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'):
                return self.get_vm_content_locally(path)
            return None
        logging.info("Trying to get VM content from all management server")
        command = f"cat {path}"
        for idx, server_ip in enumerate(server_ips):
            logging.info(f"Trying to get VM content from management server #{idx} with IP {server_ip}")
            sshClient = SshClient(
                server_ip,
                22,
                self.mgtSvrDetails["user"],
                self.mgtSvrDetails["passwd"]
            )
            results = sshClient.execute(command)
            if isinstance(results, list) and len(results) > 0:
                return '\n'.join(line.strip() for line in results)
        return None

    def check_vm_content_values(self, content):
        if content is None:
            self.fail("VM content is empty")

        try:
            data = json.loads(content)
        except json.JSONDecodeError as e:
            self.fail(f"Invalid JSON for the VM: {e}")

        if not data:
            self.fail("Empty JSON for the VM")

        required_keys = ['externaldetails', 'cloudstack.vm.details', 'virtualmachineid', 'virtualmachinename', 'status']
        if not all(key in data for key in required_keys):
            self.fail("Missing one or more required keys.")

        memory = self.compute_offering.memory * 1024 * 1024
        vm_details = data['cloudstack.vm.details']

        self.assertEqual(
            memory,
            vm_details['minRam'],
            "VM memory mismatch"
        )
        self.assertEqual(
            self.compute_offering.cpunumber,
            vm_details['cpus'],
            "VM CPU count mismatch"
        )
        self.assertEqual(
            'Running',
            data['status'],
            "VM status mismatch"
        )

    def check_vm_status_from_content(self, extension_path, vm_name, status):
        content = self.get_vm_content(extension_path, vm_name)
        if content is None:
            self.fail("VM content is empty")

        try:
            data = json.loads(content)
        except json.JSONDecodeError as e:
            self.fail(f"Invalid JSON for the VM: {e}")

        if not data:
            self.fail("Empty JSON for the VM")

        self.assertEqual(
            status,
            data['status'],
            "VM status mismatch"
        )

    def check_vm_content_exist_locally(self, path):
        try:
            file = Path(path)
            return file.exists()
        except Exception:
            return None

    def check_vm_content_exist(self, extension_path, vm_name):
        path = self.get_vm_content_path(extension_path, vm_name)
        server_ips = self.getManagementServerIps()
        if not server_ips:
            if self.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'):
                return self.check_vm_content_exist_locally(path)
            return None
        logging.info("Trying to check VM content exists from all management server")
        command = f"test -e '{path}' && echo EXISTS || echo MISSING"
        for idx, server_ip in enumerate(server_ips):
            logging.info(f"Trying to check VM content exists from management server #{idx} with IP {server_ip}")
            sshClient = SshClient(
                server_ip,
                22,
                self.mgtSvrDetails["user"],
                self.mgtSvrDetails["passwd"]
            )
            results = sshClient.execute(command)
            if results is not None and results[0].strip() == "EXISTS":
                return True
        return False

    def popItemFromCleanup(self, item_id):
        for idx, x in enumerate(self.cleanup):
            if x.id == item_id:
                self.cleanup.pop(idx)
                break

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
    def test_01_extension_vm_lifecycle(self):
        self.virtual_machine = VirtualMachine.create(
            self.apiclient,
            self.services["virtual_machine"],
            templateid=self.template.id,
            serviceofferingid=self.compute_offering.id,
            networkids=[self.l2_network.id]
        )
        self.cleanup.append(self.virtual_machine)
        self.assertEqual(
            self.virtual_machine.state,
            'Running',
            "VM not in Running state"
        )
        content = self.get_vm_content(self.extension.path, self.virtual_machine.instancename)
        self.check_vm_content_values(content)
        self.virtual_machine.stop(self.apiclient)
        self.check_vm_status_from_content(self.extension.path, self.virtual_machine.instancename, 'Stopped')
        self.virtual_machine.start(self.apiclient)
        self.check_vm_status_from_content(self.extension.path, self.virtual_machine.instancename, 'Running')
        self.virtual_machine.reboot(self.apiclient)
        self.check_vm_status_from_content(self.extension.path, self.virtual_machine.instancename, 'Running')
        self.virtual_machine.delete(self.apiclient, expunge=True)
        self.popItemFromCleanup(self.virtual_machine.id)
        self.assertFalse(
            self.check_vm_content_exist(self.extension.path, self.virtual_machine.instancename),
            "VM content exist event after expunge"
        )

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
    def test_02_run_custom_action(self):
        name = 'testaction'
        details = [{}]
        details[0]['abc'] = 'xyz'
        parameters = [{}]
        parameter0 = {
            'name': 'Name',
            'type': 'STRING',
            'validationformat': 'NONE',
            'required': True
        }
        parameters[0] = parameter0
        self.custom_action = ExtensionCustomAction.create(
            self.apiclient,
            extensionid=self.extension.id,
            name=name,
            enabled=True,
            details=details,
            parameters=parameters,
            successmessage='Successfully completed {{actionName}}'
        )
        self.cleanup.append(self.custom_action)
        self.virtual_machine = VirtualMachine.create(
            self.apiclient,
            self.services["virtual_machine"],
            templateid=self.template.id,
            serviceofferingid=self.compute_offering.id,
            networkids=[self.l2_network.id]
        )
        self.cleanup.append(self.virtual_machine)
        param_val=random_gen()
        run_parameters = [{}]
        run_parameters[0] = {
            'Name': param_val
        }
        run_response = self.custom_action.run(
            self.apiclient,
            resourceid=self.virtual_machine.id,
            parameters=run_parameters
        )
        self.assertTrue(
            run_response.success,
            "Action run status not success"
        )
        self.assertEquals(
            f"Successfully completed {name}",
            run_response.result.message,
            "Action run status not success"
        )
        data = run_response.result.details
        self.assertEquals(
            f"{param_val} for {self.virtual_machine.instancename}",
            run_response.result.details,
            "Action response details not match"
        )

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
    def test_03_run_invalid_custom_action(self):
        name = 'invalidaction'
        self.custom_action = ExtensionCustomAction.create(
            self.apiclient,
            extensionid=self.extension.id,
            name=name,
            enabled=True,
            errormessage='Failed {{actionName}}'
        )
        self.cleanup.append(self.custom_action)
        self.virtual_machine = VirtualMachine.create(
            self.apiclient,
            self.services["virtual_machine"],
            templateid=self.template.id,
            serviceofferingid=self.compute_offering.id,
            networkids=[self.l2_network.id]
        )
        self.cleanup.append(self.virtual_machine)
        run_response = self.custom_action.run(
            self.apiclient,
            resourceid=self.virtual_machine.id
        )
        self.assertFalse(
            run_response.success,
            "Action run status not failure"
        )
        self.assertEquals(
            f"Failed {name}",
            run_response.result.message,
            "Action run status not success"
        )