#!/usr/bin/python

DOCUMENTATION = r'''
---
module: decort_sdn_hypervisor

description: See L(Module Documentation,https://repository.basistech.ru/BASIS/decort-ansible/wiki/Home). # noqa: E501
'''

from typing import Any
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.decort_utils import DecortController
import requests


class DecortSDNHypervisor(DecortController):
    name: str | None = None
    _hypervisor_info: dict[str, Any] | None = None
    need_final_get: bool = True

    def __init__(self):
        super().__init__(AnsibleModule(**self.amodule_init_args))

    @property
    def amodule_init_args(self) -> dict:
        return self.pack_amodule_init_args(
            argument_spec=dict(
                display_name=dict(
                    type='str',
                ),
                name=dict(
                    type='str',
                ),
                port_info=dict(
                    type='str',
                    choices=['detailed', 'general'],
                ),
                state=dict(
                    type='str',
                    choices=['absent'],
                ),
            ),
            supports_check_mode=True,
        )

    @property
    def hypervisor_info(self) -> dict[str, Any]:
        if self._hypervisor_info is None:
            if not isinstance(self.name, str):
                raise TypeError
            hypervisor_info = self.get()
            if hypervisor_info is None:
                raise TypeError
            self._hypervisor_info = hypervisor_info
        return self._hypervisor_info

    def check_amodule_args(self):
        check_errors = False

        if self.aparams['name'] is None:
            check_errors = True
            self.message(
                'Check for parameter "name" failed: '
                'name must be specified.'
            )

        if check_errors:
            self.exit(fail=True)

    @DecortController.waypoint
    def get(self) -> dict[str, Any] | None:
        params = {'name': self.name}
        if self.aparams['port_info'] is not None:
            params['port_info'] = self.aparams['port_info']

        response = self.decort_api_call(
            arg_req_function=requests.get,
            arg_api_name='/restmachine/sdn/hypervisor/get',
            arg_params=params,
            not_fail_codes=[400],
            accept_json_response=True,
        )
        if response.status_code == 400:
            self.message(
                self.MESSAGES.obj_not_found(
                    obj='hypervisor',
                    id=self.name,
                )
            )
            self.exit(fail=True)
        return response.json()

    @DecortController.waypoint
    @DecortController.checkmode
    def update_display_name(self):
        params = {
            'name': self.aparams['name'],
            'display_name': self.aparams['display_name'],
        }
        self.decort_api_call(
            arg_req_function=requests.put,
            arg_api_name='/restmachine/sdn/hypervisor/update_display_name',
            arg_params=params,
            accept_json_response=True,
        )
        self.set_changed()

    @DecortController.waypoint
    @DecortController.checkmode
    def delete(self):
        params = {'name': self.name}
        response = self.decort_api_call(
            arg_req_function=requests.delete,
            arg_api_name='/restmachine/sdn/hypervisor/delete',
            arg_params=params,
            not_fail_codes=[400]
        )
        self.need_final_get = False
        if response.status_code == 200:
            self.set_changed()
            self.message(
                self.MESSAGES.obj_deleted(
                    obj='hypervisor',
                    id=self.name,
                )
            )
        else:
            self.message(
                self.MESSAGES.obj_not_found(
                    obj='hypervisor',
                    id=self.name,
                )
            )
        self.facts = {}

    def run(self):
        self.check_amodule_args()
        self.name = self.aparams['name']

        if self.aparams['state'] == 'absent':
            self.delete()
        else:
            if (
                self.aparams['display_name'] is not None
                and self.aparams['display_name']
                != self.hypervisor_info.get('display_name')
            ):
                self.update_display_name()

        if self.need_final_get:
            self.facts = self.get()
        self.exit()


def main():
    DecortSDNHypervisor().run()


if __name__ == '__main__':
    main()