#!C:\Python\Python311\python.exe
# -*- coding: utf-8 -*-
# device_management.py
# from datetime import datetime
import sys
import datetime
import json
import random
from flask import Flask, jsonify, render_template
from flask import make_response
from flask import request
from flask import abort
from werkzeug.routing import BaseConverter
# print("device_management sys.path")
# print(sys.path)

from . import app 
from .handlers.cl_man_regist  import  cl_man_regist

from .handlers.cl_man_req  import  cl_man_req
from utils.consts import clC
try:
    from man_db.MDB import  clMDB
    from handlers.cl_log_data_man  import cl_log_data_man
    from handlers.cl_param_man import   cl_param_man 
    from handlers.cl_man_cmds import cl_man_cmds
       
    print

except Exception as inst:
    print ("Content-type: text/html ;\n\n")
    print
    print("device_management import      Exception")
    m = type(inst)
    print(type(inst))  # the exception type
    print(inst.args)  # arguments stored in .args
    print(inst)  # __str__ allows args to be printed directly,
DEBUG_SAIT = False
DEBUG_SAIT = True#d++
v_clMDB = clMDB()
 

@app.route('/' + clC.url_Device_management_f + '/', methods=['GET'])  # 28-10-20236:51
# @app.route('/device_management/device_management/', methods=['GET'])  # 28-10-20236:51
def device_management():  # 16-09-202312:59
    print("device_management args")
    print(str(request.args))
       
    if 'useremail' in request.args:
        useremail = request.args.get('useremail')  
        # {"id": ,"id_telegram": }
        ans = cl_man_regist.check_key_sec(request.args.get('key_sec'))
        ans["id_telegram"] = int(ans["id_telegram"])
        is_key_sec = ans["id_telegram"] 
        if ans["id_telegram"] > 0:
            cl_man_regist.send_message(ans["id_telegram"], clC.g("Device_management"))
        else: 
            cl_man_regist.send_message(ans['id_telegram_self'], clC.g("mes_session_time_ended"))
            print("device_management id_telegram!>0 {} ".format(is_key_sec))
              
    is_win = cl_man_req.is_win()
    user = 'device_management'
    data = {"user":user, "is_win":is_win, "DEBUG_SAIT":DEBUG_SAIT} 
    #
    return render_template('device_management.html', data=data)


@app.route('/param_change/', methods=['GET'])  # 25-12-202317:55 #29-12-202310:07
async def param_change(): 
    print("param_change args")
    print(str(request.args))
    vals_request = request.args
    vals_request = vals_request.to_dict()
    print(str(vals_request))
    v_cl_param_man = cl_param_man()
    ans = check_key_sec_get_mac(vals_request['key_sec'], "dis_param")
    print("param_change ans")
    print(ans)
    if str(type(ans)) != "<class 'dict'>": 
        return ans
    mac = ans["mac"]    
    result = await v_cl_param_man.param_change(mac, vals_request)
    print("param_change result")
    print(result)
    return {'result':result}


def check_key_sec_get_mac(key_sec, act):  # 25-12-202317:55
    mes_info = "work"
    if act == "dis_param": 
        mes_info = clC.url_dis_param_f
        
    # ans = cl_man_regist.check_key_sec(request.args.get('key_sec'), True)

    ans = cl_man_regist.check_key_sec(key_sec, True)
    ans["id_telegram"] = int(ans["id_telegram"])
    is_key_sec = ans["id_telegram"] 
    app.logger.warning("check_key_sec_get_mac ans>>> %s", str(ans))
    print(is_key_sec)
    if ans["id_telegram"] > 0:
        pass
        # cl_man_regist.send_message(ans["id_telegram"], mes_info)
    else: 
        # cl_man_regist.send_message(ans['id_telegram_self'], clC.g("mes_session_time_ended"))
        print("dis_param id_telegram!>0 {} ".format(is_key_sec))
        # return jsonify(ans["id_telegram"])
        return ans["id_telegram"]
        # return jsonify(clC.g("mes_session_time_ended_adv"))
    
    id_sel_device = v_clMDB.get_id_sel_deviceBYid_telegram(ans["id_telegram"])
    one = v_clMDB.get_sel_device(id_sel_device, ans["id_telegram"])
    one["id_telegram"] = ans["id_telegram"]
    print(str(one))
    # mac = one["mac"]
    return one


@app.route('/' + clC.url_dis_param_f + '/', methods=['GET'])  # 28-10-20236:51
async def dis_param():  # 25-12-202317:55 
    print("dis_param args")
    print(str(request.args))
    app.logger.warning("dis_param args>>> %s", str(request.args))


    #return jsonify(0) 
    is_win = cl_man_req.is_win()
    mac = ""
 
    DEBUG_SAIT_L = False
    if 'DEBUG_SAIT' in request.args:
        DEBUG_SAIT=request.args.get('DEBUG_SAIT')
        if DEBUG_SAIT== "True":
            DEBUG_SAIT_L = True
    print("dis_param DEBUG_SAIT_L>>> %s", str(DEBUG_SAIT_L))
    print("dis_param is_win>>> %s", str(is_win))

    
    if DEBUG_SAIT_L == False or is_win != 0:
        ans = check_key_sec_get_mac(request.args.get('key_sec'), "dis_param")
        print('dis_param str(type(ans))=' + str(type(ans)))
        if str(type(ans)) != "<class 'dict'>": 
            return ans
        mac = ans["mac"]    
        v_cl_log_data_man = cl_log_data_man(mac)
        vals = v_cl_log_data_man.Get_the_current_array_fromDB()
        print('dis_param vals=' + str(vals))
    else:
        vals = {"user":0}
    vals_javascript = json.dumps(vals)
    v_cl_param_man = cl_param_man() 
    # Names  
    # dispHTML# HTML information to display
    # edHTML# HTML information for editing
    await  v_cl_param_man.creation_params_DataWeb(mac)
    ArParameters = v_cl_param_man.params_dict_web
    ar_params_ch = v_cl_param_man.ar_params_ch
    print('dis_param ArParameters=' + str(ArParameters))
    vals_len = len(vals)   
    
    user = 'dis_param<input type="text" id="name" name="name" required minlength="4" maxlength="8" size="10" />'
    user = ''
    data = {"vals":vals, "vals_len":vals_len,  # 25-12-202317:55
            "ArParameters":ArParameters,
            "ar_params_ch":ar_params_ch,
             "user":user, "is_win":is_win, "DEBUG_SAIT":DEBUG_SAIT} 
    try:
        vals_javascript = json.dumps(data)    
    except Exception as inst:
        print("device_management dis_param      Exception")
        m = type(inst)
        print(type(inst))  # the exception type
        print(inst.args)  # arguments stored in .args
        print(inst)  # __str__ allows args to be printed directly,
    
    return render_template('dis_param.html', data=data)


@app.route('/' + clC.url_dis_param_cmd_f + '/', methods=['GET'])  # 28-10-20236:51
async def dis_param_cmd():  # 25-12-202317:55 
    print("dis_param_cmd args")
    print(str(request.args))

# return jsonify(0) 
    is_win = cl_man_req.is_win()
    mac = ""
    # DEBUG_SAIT= False
    global DEBUG_SAIT
 
    DEBUG_SAIT_L = False
    if 'DEBUG_SAIT' in request.args:
        DEBUG_SAIT=request.args.get('DEBUG_SAIT')
        print('dis_param_cmd DEBUG_SAIT=' + str(DEBUG_SAIT))
        if DEBUG_SAIT== "True" or DEBUG_SAIT==  True :
            DEBUG_SAIT_L = True
    id_telegram=None
    ans =m = 0
    print('dis_param_cmd is_win=' + str(is_win))
    if DEBUG_SAIT_L == False or is_win == 1:
        ans = check_key_sec_get_mac(request.args.get('key_sec'), "dis_param_cmd")
        print('dis_param_cmd str(type(ans))=' + str(type(ans)))
        print('dis_param_cmd ans=' + str(ans))
        if str(type(ans)) != "<class 'dict'>": 
            if ans == 0:
                data = {"m":clC.g("mes_session_time_ended_adv"), "user":0, "is_win":is_win, "DEBUG_SAIT":DEBUG_SAIT}
                return render_template('sess_end.html', data=data)
            else:
                return ans 
        id_telegram=ans["id_telegram"]
        print('dis_param_cmd DEBUG_SAIT_L=' + str(DEBUG_SAIT_L))       
        cmd_data = "/help"  # todo
        if 'cmd' in request.args:#ajax
            cmd_data = request.args.get('cmd')        
    
        v_cl_man_cmds = cl_man_cmds()  # 11-12-202311:23
        lang =clC.ID_lang
        if id_telegram is not None:
            if id_telegram > 0:
                lang = cl_man_req.get_lang(id_telegram,lang, app)
                if 'cmd' not in request.args:
                    clC.send_message(id_telegram,  clC.url_dis_param_cmd_f)
                #cl_man_regist.send_message(id_telegram, clC.url_dis_param_cmd_f)

        
        clC.ID_lang= v_clMDB.get_id_lang(id_telegram, lang)
        IsCommand = await v_cl_man_cmds.IsCommand(None, ans["id_telegram"], ans["mac"], cmd_data)  # 11-12-202311:23
        if IsCommand == False:
            m = clC.g("mess_Invalid_command_format")
        else:
            m = IsCommand
        if 'cmd' in request.args:#ajax
            return {'m':m}
    # else:#start view
    #     m = ""
    user = ''
    data = {
"Reference":clC.g("Reference" ),
"Clear":clC.g("Clear" ),
"Send":clC.g("Send" ),
"m":m, "user":user, "is_win":is_win, "DEBUG_SAIT":DEBUG_SAIT}
     
    # data = {"vals":0,  "user":user, "is_win":is_win, "DEBUG_SAIT":DEBUG_SAIT} 
    #
    return render_template('dis_param_cmd.html', data=data)

@app.route('/' + clC.url_change_language_f + '/', methods=['GET'])  #29-11-202313:32 28-10-20236:51
async def change_language():  # 25-12-202317:55 
    print("change_language args")
    print(str(request.args))
    global DEBUG_SAIT

    request_data = {}
    id_telegram = None
    lang_new = None
    if 'API_KEY' in request.args:
        API_KEY = request.args.get('API_KEY')  
    if 'lang_new' in request.args:
        lang_new = request.args.get('lang_new')  
    if 'key_sec' in request.args:
        request_data['key_sec'] = request.args.get('key_sec')  
    ans = cl_man_regist.check_key_sec(request.args.get('key_sec'), True)
    print('change_language ans0=' + str(ans))
    ans["id_telegram"] = int(ans["id_telegram"])
    is_key_sec = ans["id_telegram"] 
    if ans["id_telegram"] > 0:
        id_telegram = ans["id_telegram"]
        pass
    else: 
        if 'DEBUG_SAIT' in request.args:
            DEBUG_SAIT=request.args.get('DEBUG_SAIT')
            print('change_language DEBUG_SAIT=' + str(DEBUG_SAIT))
            if DEBUG_SAIT== "True" or DEBUG_SAIT==  True :
                pass
                #id_telegram = 0
            else:
                cl_man_regist.send_message(ans['id_telegram_self'], clC.g("mes_session_time_ended"))
                print("change_language id_telegram!>0 {} ".format(is_key_sec))
                return jsonify({'result':clC.v_error, 'desc':clC.g("mes_session_time_ended_adv")})

    print('change_language id_telegram=' + str(id_telegram))
    if lang_new != None and id_telegram is not None:
        ans = cl_man_req.Ch_lang(id_telegram, lang_new, app)
        if ans == 0:
            ans = 'OK'
        return jsonify({'result':ans}) 
    #
    # else:
    #     mac = request.args.get('mac')
    
    v_cl_man_cmds = cl_man_cmds()
    dicLang= list(v_cl_man_cmds.dicLang.keys())
    # d =jsonify(request.json)
    #print(mac)
    #tzone = cl_man_req.get_TZONE_BYmac(mac, app)
    lang =clC.ID_lang
    if id_telegram is not None:
        if id_telegram > 0:
            clC.send_message(id_telegram,  clC.url_change_language_f)
            lang = cl_man_req.get_lang(id_telegram,lang, app)
    print("change_language lang=" + str(lang))
    is_win = cl_man_req.is_win()
    user = lang or 'Shalabheeee'
    data = {"user":user, 
            "langs":dicLang,
             "lang":lang,
             "mess_Change":clC.g("mess_Change" ),
             "tit_Setting_language":clC.g("tit_Setting_language" ),
             "note_Choose_language":clC.g("note_Choose_language" ),
            "is_win":is_win, "DEBUG_SAIT":DEBUG_SAIT} 

    return render_template('change_language.html', data=data)