from apps.customer.models import (
    ResponsibleGroup as ResponsibleGroupModel,
    ShiveAshenaei as ShiveAshenaeiModel,
    Customer as CustomerModel,
    CustomerNote as CustomerNoteModel
)
from apps.reminder.models import Reminder as ReminderModel
from apps.workspace.models import Workspace as WorkspaceModel
from apps.cuser.models import CuserRole as CuserRoleModel
from rest_framework import exceptions
from utils.get_user_workspace import get_user_workspace, get_user_workspace_uuid
from utils.get_cuser_role import get_cuser_role
from django.db import transaction
from django.contrib.auth import get_user_model
import uuid
import random

CUser = get_user_model()


@transaction.atomic
def customer_panel_access(request, mobile: int, customer_id: int, status: bool) -> CuserRoleModel:

    try:
        workspace = get_user_workspace(request)
        customer = CustomerModel.objects.get(id=customer_id, sys_ws=workspace)

        try:
            cuser_obj = CUser.objects.get(mobile=mobile)
        except CUser.DoesNotExist:
            cuser_obj = CUser.objects.create_user(
                username=uuid.uuid4(),
                mobile=mobile,
                name_family=customer.name_family,
                password=f"{random.randint(10000, 900000)}!@#{random.randint(10000, 9000000)}",
                is_active=True,
            )

        try:
            cuser_role_obj = CuserRoleModel.objects.get(cuser=cuser_obj, role_type_id=3)
            cuser_role_obj.customer_panel = status
            cuser_role_obj.save()
        except CuserRoleModel.DoesNotExist:
            cuser_role_obj = CuserRoleModel.objects.create(
                cuser=cuser_obj,
                role_type_id=3,
                name_family=customer.name_family,
                mobile=mobile,
                mobile_verify=True,
                is_active=True,
                customer_panel=status,
                sys_ws=workspace
            )

        if cuser_role_obj:
            customer.cuser_role = cuser_role_obj
            customer.save()
            return cuser_role_obj
        else:
            raise Exception

    except Exception as exp:
        message = f'Error Create or Update Customer panel accsess: {exp}'
        raise exceptions.ValidationError({'error': message})


def create_responsible_group(name: str, workspace: WorkspaceModel):
    try:
        responsible_group_obj = ResponsibleGroupModel(name=name, sys_ws=workspace)
        responsible_group_obj.full_clean()
        responsible_group_obj.save()

        return responsible_group_obj

    except Exception as exp:
        message = f'Error creating ResponsibleGroup: {exp}'
        raise exceptions.ValidationError({'error': message})


def delete_responsible_group(responsible_group_id: int, workspace_uuid: str):
    try:
        ResponsibleGroupModel.objects.get(id=responsible_group_id, sys_ws__uuid=workspace_uuid).delete()
    except Exception as exp:
        message = f'Error Deleting ResponsibleGroup: {exp}'
        raise exceptions.ValidationError({'error': message})


def create_shive_ashenaei(name: str, workspace: WorkspaceModel) -> ShiveAshenaeiModel:
    try:
        shive_obj = ShiveAshenaeiModel(name=name, sys_ws=workspace)
        shive_obj.full_clean()
        shive_obj.save()
        return shive_obj
    except Exception as exp:
        message = f'Error creating ShiveAshenaei: {exp}'
        raise exceptions.ValidationError({'error': message})


def delete_shive_ashenaei(shive_id: int, workspace_uuid: str) -> ShiveAshenaeiModel:
    try:
        ShiveAshenaeiModel.objects.get(id=shive_id, sys_ws__uuid=workspace_uuid).delete()
    except Exception as exp:
        message = f'Error Delete ShiveAshenaei: {exp}'
        raise exceptions.ValidationError({'error': message})


def create_customer(name_family: str , mobile: int, phone: int, address: str, city: int, shive_ashenaei: int,
                    responsible_group: int, cuser_role: int = None, workspace: WorkspaceModel = None) -> CustomerModel:
    try:
        customer_obj = CustomerModel()
        customer_obj.name_family = name_family
        customer_obj.mobile = mobile
        customer_obj.phone = phone
        customer_obj.address = address
        customer_obj.city = city
        customer_obj.shive_ashenaei = shive_ashenaei
        customer_obj.responsible_group = responsible_group
        if cuser_role is not None:
            customer_obj.cuser_role = cuser_role
        customer_obj.sys_ws = workspace

        customer_obj.full_clean()
        customer_obj.save()
        return customer_obj
    except Exception as exp:
        message = f'Error Creating Customer: {exp}'
        raise exceptions.ValidationError({'error': message})


def update_customer(customer_id: int, name_family: str = None , mobile: int = None, phone: int = None, address: str = None,
                    city: int = None, shive_ashenaei: int = None, responsible_group: int = None, cuser_role: int = None, workspace_uuid: str = None) -> CustomerModel:
    try:
        customer_obj = CustomerModel.objects.get(id=customer_id, sys_ws__uuid=workspace_uuid)

        if name_family is not None:
            customer_obj.name_family = name_family
        if mobile is not None:
            customer_obj.mobile = mobile
        if phone is not None:
            customer_obj.phone = phone
        if address is not None:
            customer_obj.address = address
        if city is not None:
            customer_obj.city = city
        if shive_ashenaei is not None:
            customer_obj.shive_ashenaei = shive_ashenaei
        if responsible_group is not None:
            customer_obj.responsible_group = responsible_group
        if cuser_role is not None:
            customer_obj.cuser_role = cuser_role

        customer_obj.full_clean()
        customer_obj.save()
        return customer_obj
    except Exception as exp:
        message = f'Error Creating Customer: {exp}'
        raise exceptions.ValidationError({'error': message})


def delete_customer(customer_id: int, workspace_uuid: str = None) -> CustomerModel:
    try:
        CustomerModel.objects.get(id=customer_id, sys_ws__uuid=workspace_uuid).delete()
    except Exception as exp:
        message = f'Error Deleting Customer: {exp}'
        raise exceptions.ValidationError({'error': message})


def create_customer_v2(request, name_family: str , mobile: int, phone: int, address: str, city: int, shive_ashenaei: int,
                    responsible_group: int, cuser_role: int = None) -> CustomerModel:
    try:
        workspace = get_user_workspace(request=request)

        customer_obj = CustomerModel()
        customer_obj.name_family = name_family
        customer_obj.mobile = mobile
        customer_obj.phone = phone
        customer_obj.address = address
        customer_obj.city_id = city
        customer_obj.shive_ashenaei = ShiveAshenaeiModel.objects.get(id=shive_ashenaei, sys_ws=workspace)

        customer_obj.responsible_group = ResponsibleGroupModel.objects.get(id=responsible_group, sys_ws=workspace)
        if cuser_role is not None:
            customer_obj.cuser_role = cuser_role
        customer_obj.sys_ws = workspace

        customer_obj.full_clean()
        customer_obj.save()
        return customer_obj
    except Exception as exp:
        message = f'Error Creating Customer: {exp}'
        raise exceptions.ValidationError({'error': message})


def create_customer_note(request, customer_id: int, desc: str,
                         reminder_datetime: str = None, reminder_desc: str = None) -> CustomerNoteModel:
    with transaction.atomic():
        try:
            workspace = get_user_workspace(request=request)
            cuser_role = get_cuser_role(request=request)

            customer_note = CustomerNoteModel()
            customer_note.customer = CustomerModel.objects.get(id=customer_id, sys_ws=workspace)
            customer_note.desc = desc
            customer_note.sys_ws = workspace
            customer_note.cuser_role = cuser_role
            customer_note.save()

            if reminder_datetime:
                try:
                    reminder = ReminderModel()
                    reminder.type = 'NO'
                    reminder.note = customer_note
                    reminder.id_type = customer_note.id
                    reminder.customer = customer_note.customer
                    reminder.datetime = reminder_datetime
                    if reminder_desc:
                        reminder.desc = reminder_desc
                    reminder.cuser_role = cuser_role
                    reminder.sys_ws = workspace
                    reminder.save()

                except Exception as exp:
                    transaction.set_rollback(True)
                    message = f'Error Creating Customer Note and Set Reminder: {exp}'
                    raise exceptions.ValidationError({'error': message})

            return customer_note

        except Exception as exp:
            transaction.set_rollback(True)
            message = f'Error Creating Customer Note: {exp}'
            raise exceptions.ValidationError({'error': message})


def customer_note_edit(request, customer_id: int, note_id: int, desc: str,
                       reminder_datetime: str = None, reminder_desc: str = None) -> CustomerNoteModel:
    try:
        workspace = get_user_workspace(request)
        cuser_role = get_cuser_role(request)

        customer_note = CustomerNoteModel.objects.get(id=note_id, customer_id=customer_id, sys_ws=workspace)
        customer_note.desc = desc
        customer_note.save()

        if reminder_datetime:
            try:
                try:
                    reminder = ReminderModel.objects.get(type='NO', note=customer_note, id_type=note_id, customer_id=customer_id)
                    reminder.datetime = reminder_datetime
                    reminder.desc = reminder_desc
                    reminder.save()
                except Exception as exp:
                    try:
                        reminder = ReminderModel()
                        reminder.type = 'NO'
                        reminder.note = customer_note
                        reminder.id_type = customer_note.id
                        reminder.customer = customer_note.customer
                        reminder.datetime = reminder_datetime
                        if reminder_desc:
                            reminder.desc = reminder_desc
                        reminder.cuser_role = cuser_role
                        reminder.sys_ws = workspace
                        reminder.save()
                    except Exception as exp:
                        print(exp)
            except Exception as exp:
                print(exp)

        return customer_note

    except Exception as exp:
        message = f'Error Edit Customer Note: {exp}'
        raise exceptions.ValidationError({'error': message})


def customer_note_delete(request, customer_id: int, note_id: int) -> CustomerNoteModel:
    try:
        workspace = get_user_workspace_uuid(request=request)

        customer_note = CustomerNoteModel.objects.get(id=note_id, customer_id=customer_id, sys_ws__uuid=workspace).delete()

        return customer_note

    except Exception as exp:
        message = f'Error Delete Customer Note: {exp}'
        raise exceptions.ValidationError({'error': message})