import time

from layer import Layer
from field import Field
from user import User
from user_field import FieldRecord
from datetime import datetime





class Service:
    layer = Layer(LAYER)  #初始化数据库数据并启动增删查功能


    #普通用户操作：
    #请求一条场地使用信息（普通用户自动传入自己的用户id，管理员用户手动选择传入用户id）  #redis
    #参数：cs_fieldRecord(用户id，场地id，开始时间，结束时间)    返回：bool 是否预约成功
    def AddAppointment(self,cs_fieldRecord) -> bool:
        fieldRecord=FieldRecord(cs_fieldRecord)
        records=self.layer.find_record("fid",fieldRecord.fid)
        #如果用户已经有预约了，就不能再提交预约
        if len(self.layer.find_record("uid",fieldRecord.uid))!=0:
            raise ValueError("Already has an appointment")
        else:
            #检查场地此时是否有空
            for x in records:
                if not((x.end_time>=fieldRecord.start_time) or (x.start_time<=fieldRecord.end_time)):
                    raise ValueError("Field busy")
        #添加记录
        self.layer.add_record(fieldRecord)
        return True


    #提前结束场地的使用 正在使用时提前结束    #finished
    #参数：cs_user  //cs_fieldRecord(用户id，场地id，开始时间，)    返回：bool 是否结束成功
    def EndAppointment(self,cs_user) -> bool:
        user=User(cs_user)
        records=self.layer.find_record("uid",user.uid)
        if len(records)==0:
            raise ValueError("No appointment")
        elif len(records) !=1:
            raise ValueError("Appointment nums error")
        else:
            fid = records[0].fid
            uid = user.id
            start_time = records[0].start_time
            #获取当前时间并转为%Y-%m-%d %H:%M:%S形式的字符串
            curtime=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            #正在使用时可以提前结束，修改结束时间
            if curtime>=start_time and curtime<records[0].end_time:
                fieldRecord=FieldRecord(fid,uid,start_time,curtime)
                self.layer.remove_record(records[0])
                self.layer.add_record(fieldRecord)
                return True
            else:
                raise ValueError("No ongoing appointment")



    #取消预约
    # 参数：cs_user //cs_fieldRecord(用户id，场地id，开始时间，结束时间)   返回：bool 是否取消成功
    def CancelAppointment(self,cs_user) -> bool:
        user=User(cs_user)
        records=self.layer.find_record("uid",user.id)
        if len(records)==0:
            raise ValueError("No appointment or appointment is finished")
        elif len(records)!=1:
            raise ValueError("Appointment nums error")
        else:
            curtime=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            if curtime<records[0].start_time:
                fieldRecord=FieldRecord(records[0])
                return True
            else:
                raise ValueError("Appointment has started")


    #延长场地的使用时间    #redis
    # 参数：cs_fieldRecord(用户id，场地id(null)，开始时间(null)，结束时间)   返回：bool 是否延长成功
    def ExtendAppointment(self,cs_fieldRecord) -> bool:
        field_Record=FieldRecord(cs_fieldRecord)
        records=self.layer.find_record("uid", field_Record.uid)
        if len(records)==0:
            raise ValueError("No appointment or appointment is finished")
        elif len(records)!=1:
            raise ValueError("Appointment nums error")
        else:
            curtime=datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            start_time=records[0].start_time
            end_time=records[0].end_time
            if curtime>=start_time and curtime<end_time:
                addrecord=FieldRecord(field_Record.uid, records[0].fid, start_time, field_Record.end_time)
                self.layer.add_record(addrecord)
                return True
            else:
                raise ValueError("Appointment is finished or not started")


    #查询场地占用
    # 参数：cs_fieldRecord(用户id(null)，场地id，开始时间(null)，结束时间(null))     返回：list_time  [(start_time,end_time),(...),(...),...]
    def parse_time(time_str):
        return datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S").time()

    def QueryFieldUsage(self,cs_fieldRecord) -> []:
        fid=FieldRecord(cs_fieldRecord).fid
        records=self.layer.find_record("fid",fid)
        list_time=[]
        for x in records:
            tup=(x.start_time,x.end_time)
            list_time.append(tup)
        # 使用 sorted() 函数进行排序，key 参数指定用于排序的键函数
        sorted_time_list = sorted(list_time, key=lambda x: self.parse_time(x[0]))
        #从后往前遍历
        for x in range(len(sorted_time_list)-1,0,-1):
            strtm2 = sorted_time_list[x][0]
            strtm1 = sorted_time_list[x - 1][1]
            timestamp1 = time.mktime(time.strptime(strtm1, "%Y-%m-%d %H:%M:%S"))
            timestamp2 = time.mktime(time.strptime(strtm2, "%Y-%m-%d %H:%M:%S"))
            if (timestamp2 - timestamp1) / 60 <= 10:
                tup = (sorted_time_list[x - 1][0], sorted_time_list[x][1])
                sorted_time_list.pop(x)
                sorted_time_list[x - 1] = tup
        return sorted_time_list





    #查询用户的预约记录
    # 参数：cs_user(id)   返回：array_cs_fieldRecord
    def QueryAppointmentRecord(self,cs_user) -> []:
        user=User(cs_user)
        

    #管理员操作：（包含普通用户操作以及一下特殊操作）

    #添加一个场地
    #参数：cs_field(id,name,position,open_time,type)  返回：bool 是否添加成功
    def AddField(self, cs_field) -> str:
        field = Field(cs_field)
        self.layer.add_field(field)
        return ""

    #删除一个场地
    # 参数：cs_field(id,name,position(null),open_time(null),type(null))  返回：bool 是否删除成功