import os
import requests
import logging
import traceback
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from slack_sdk import WebClient
from lib import log 

my_client = WebClient(token=os.environ.get("SLACK_BOT_TOKEN"))
app = App(token=os.environ.get("SLACK_BOT_TOKEN"))

def send_request(username, server, hours):
    res_code = 200
    res_msg = "sucess"
    return res_code, res_msg

@app.command("/reserve")
def reserve_server(ack, respond, command, body):
    result = "init"
    try:
        ack()
        logging.info(body)
        user_id = body["user_id"]
        result = my_client.users_info(
            user=user_id
        )
        email = result["user"]["profile"]["email"]
        logging.info(f"current user email is: {email}")
        username = email.split("@")[0]
        user_input = body["text"]
        logging.info(f"User input is: {user_input}")
        str_list = user_input.strip().split(" ")
        server = str_list[0].strip()
        hours = -1
        for s in range(1, len(str_list)):
            temp = str_list[s].strip()
            if temp.isdigit():
                hours = temp
                break
        if hours == -1:
            result = "Invalid input"
        else:
            status_code, resp_msg = send_request(username, server, hours)
            if status_code == 200:
                result = "Successfully reserve server"
            else:
                result = "Fail to reserve server"
    except Exception as e:
        logging.error(traceback.print_exc())
        result = "Fail to process your command: {}".format(e)
    finally:
        logging.info(result)
        respond(text=result)

@app.error
def custom_error_handler(error, body, logger):
    logger.exception(f"Error: {error}")
    logger.info(f"Request body: {body}")

if __name__ == "__main__":
    log.my_log('./log/reserve')
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    handler.start()

import os
import logging
import logging.handlers

def my_log(log_path, level=logging.DEBUG, when="D", backup=7,
             format="%(levelname)s: %(asctime)s: %(filename)s:%(lineno)d * %(thread)d %(message)s",
             datefmt="%m-%d %h:%m:%s"):
    my_formatter = logging.Formatter(format, datefmt)
    logger = logging.getLogger()
    logger.setLevel(level)

    dir = os.path.dirname(log_path)
    if not os.path.isdir(dir):
        os.makedirs(dir)

    handler = logging.handlers.TimedRotatingFileHandler(log_path + ".log",
                                                        when=when,
                                                        backupCount=backup)
    handler.setLevel(level)
    handler.setFormatter(my_formatter)
    logger.addHandler(handler)