#
# <one line to give the program's name and a brief idea of what it does.>
# SPDX-FileCopyrightText: 2022 gothic <email>
# SPDX-License-Identifier: GPL-3.0-or-later
#

from csharp_dao import cloudServiceDAO_pb2_grpc, cloudServiceDAO_pb2
from python_fortanix import fortanix_pb2_grpc as pb2_grpc, fortanix_pb2 as pb2
from flask import jsonify
import grpc
import base64
import json
import re

from google.protobuf.json_format import MessageToJson

class Fortanix:
  
  HOST_SRV_FRTNX = "python-fortanix-trcloud:8447"
  HOST_SRV_DAO = "localhost:8443"

  def main(request, PATH_APP):
    try:
      data_form = (base64.b64decode(request.form['data_form_config_r']) if len(request.form.getlist('data_form_config_r')) > 0 else 'NOTFOUND')
      dtfrm_json_results = json.loads(data_form)
      email = dtfrm_json_results['email_fortanix']
      tenant_vcloud = (request.form['tenant_vcloud'] if len(request.form.getlist('tenant_vcloud')) > 0 else 'NOTFOUND')
      user_vcloud = (request.form['user_vcloud'] if len(request.form.getlist('user_vcloud')) > 0 else 'NOTFOUND')
      plan_id = (request.form['planid'] if len(request.form.getlist('planid')) > 0 else 'NOTFOUND')
      rslt_clnt_frtnx = Fortanix.clnt_frtnx(email, tenant_vcloud, Fortanix.credentials_srvfrtnx(PATH_APP))
      #Fortanix.save_subscription(rslt_clnt_frtnx, user_vcloud, plan_id, Fortanix.credentials_dao(PATH_APP))
      return {
        "message": "Se genero satisfactoriamente el acceso al portal, se le hara llegar un correo con la invitacion.",
        "valid": True,
        "class": "alert-success"
      }
    except Exception as e:
      print(e)
      return {
        "message": "Ocurrio un error al generar el acceso al portal, puede intentarlo mas tarde o contactar a mesa de ayuda.",
        "valid": False,
        "class": "alert-danger"
      }
  
  def credentials_dao(path_app):
    with open(path_app + "/App/certs/csharp_dao/" +"ca.pem", "rb") as fp:
      ca_cert = fp.read()
    creds = grpc.ssl_channel_credentials(ca_cert)
    return creds
  
  def save_subscription(data_form, user_vcd, plan_id, credential):
    core_channel = grpc.secure_channel(Fortanix.HOST_SRV_DAO, credential)
    stub_usr = cloudServiceDAO_pb2_grpc.servicioDAOServiceStub(core_channel)
    req_usr = cloudServiceDAO_pb2.GetUserVCDRequest(user_name=user_vcd)
    res_usr = stub_usr.getUserVCD(req_usr)
    reusr = json.loads(MessageToJson(res_usr))
    print(reusr)
    print(type(reusr))
    id_usr_vcd = reusr["users"][0]["userVCDId"]

    req_srv_contract = cloudServiceDAO_pb2.SetContractedServicesRequest(
      backup_scheduled_id=0,
      firewall_id=0,
      plan_id=int(plan_id),
      user_id=int(id_usr_vcd),
    )
    res_srv_contract = stub_usr.GetContractedServicesRequest(req_srv_contract)

    print(res_srv_contract)

  def credentials_srvfrtnx(path_app):
    with open(path_app + "/App/certs/python_fortanix/" +"ca.pem", "rb") as fp:
      ca_cert = fp.read()
    recommendations_channel = grpc.secure_channel(
      Fortanix.HOST_SRV_FRTNX, grpc.ssl_channel_credentials(ca_cert)
    )
    return recommendations_channel
  
  def clnt_frtnx(email, tenant, credentials):
    # return {
    #   "account_uid": "acct.id", 
    #   "account_role_uid": "acct_role.id", 
    #   "account_group_uid": "group.id", 
    #   "account_group_role_uid": "group_role.id", 
    #   "account_user_uid": "user.id"
    # }
    client = pb2_grpc.ConsumerStub(credentials)
    request = pb2.AccountToCreate(acct_name=tenant)
    response = client.CreateAccount(request)
    acct = response.res[0]
    request_role = pb2.RoleToCreate(role_name="Account Role",role_desc="Default Role",acct_id=acct.id)
    response_role = client.CreateAccountRole(request_role)
    acct_role = response_role.res[0]
    request_group = pb2.GroupToCreate(group_name="Apps Container",group_desc="Apps",acct_id=acct.id)
    response_group = client.CreateGroup(request_group)
    group = response_group.res[0]
    request_grole = pb2.RoleToCreate(role_name="App Auditor",role_desc="Group Role",acct_id=acct.id)
    response_grole = client.CreateGroupRole(request_grole)
    group_role = response_grole.res[0]
    request_user = pb2.UserToCreate(mail=email,group_id=group.id,group_role=group_role.id,acct_id=acct.id,acct_role=acct_role.id)
    response_user = client.CreateUser(request_user)
    user = response_user.res[0]
    return {
      "account_uid": acct.id, 
      "account_role_uid": acct_role.id, 
      "account_group_uid": group.id, 
      "account_group_role_uid": group_role.id, 
      "account_user_uid": user.id
    }