def schedule(self, totalDayNum):
        scheduleResult = ScheduleResult()
        totalDayNum = int(totalDayNum)
        if self.workerNum < self.dailyRequiredWorkerNum:
            print('worker number less than workload, cannot schedule')
            scheduleResult.message = u'总员工人数小于每天出勤人数,无法排班'
            return scheduleResult
        if self.workerNum == self.dailyRequiredWorkerNum:
            print('worker number equals to workload, don\'t need to schedule at all')
            scheduleResult.message = u'总员工人数等于每天出勤人数,无需排班'
            return scheduleResult
        if self.MIN_WORK_DAY > self.maxWorkDay:
            print('min day > max day')
            scheduleResult.message = u'最大连续出勤天数设置无法保证连续出勤'
            return scheduleResult
        if self.MIN_WORK_DAY == self.maxWorkDay:
            if self.workerNum < self.dailyRequiredWorkerNum * 2:
                print('min=max but workers < workload * 2, not enough worker to handle the workload')
                scheduleResult.message = u'最大最小连续出勤数相等且总员工数小于每天出勤人数的两倍,人手不足'
                return scheduleResult
            else:
                # 固定班次的话,则误差可能为固定连续出勤数
                self.MAX_DELTA_DAY = self.MIN_WORK_DAY
        # 这种情况包含了上一种情况
        if self.workerNum < self.dailyRequiredWorkerNum * 2:
            if self.maxWorkDay < self.MIN_WORK_DAY * 2:
                print('min * 2 > max while workers < workload * 2, not enough worker to handle the workload')
                scheduleResult.message = u'总员工数小于每天出勤人数的两倍,且最大连续出勤天数小于最小连续出勤天数的两倍,人手不足'
                return scheduleResult
        workerNum = self.workerNum
        # 平均工时每人(天),向上取整
        targetTotalWorkDay = int(totalDayNum * self.dailyRequiredWorkerNum + workerNum - 1) / workerNum

        if self.MIN_WORK_DAY > targetTotalWorkDay:
            scheduleResult.message = u'最小连续工时大于平均工时,不能平均安排工时'
            return scheduleResult

        retryCnt = 0
        minDelta = 99999
        unBalancedResult = dict()
        while retryCnt < self.MAX_RETRY_TIME:
            retryCnt += 1
            [resultCalendar, workStats] = self.doSchedule(totalDayNum)
            if self.validateSchedule(resultCalendar):
                currentDelta = self.getMaxDelta(resultCalendar, totalDayNum)
                if currentDelta <= self.MAX_DELTA_DAY:
                    logging.debug('after %d time\'s retry', retryCnt)
                    scheduleResult.message = u'排班成功且工时较为平均'
                    scheduleResult.workCalendar = resultCalendar
                    scheduleResult.personalTotalWorkDay = self.calculateWorkDayPerWorker(resultCalendar)
                    scheduleResult.restCalendar = self.getRestCalendar(resultCalendar)
                    return scheduleResult
                else:
                    # 如果不够平均,则取目前最平均的排班返回
                    logging.debug('minDelta %d current %d', minDelta, currentDelta)
                    if minDelta > currentDelta:
                        unBalancedResult = resultCalendar
                        minDelta = currentDelta

        logging.debug('Cannot meet min delta requirement after %d retries', self.MAX_RETRY_TIME)

        if unBalancedResult:
            scheduleResult.message = u'排班成功但没有找到工时最平均方案'
            scheduleResult.workCalendar = unBalancedResult
            scheduleResult.personalTotalWorkDay = self.calculateWorkDayPerWorker(unBalancedResult)
            scheduleResult.restCalendar = self.getRestCalendar(unBalancedResult)
            self.printFormatedCalendar(unBalancedResult)
            logging.debug(self.getMaxDelta(unBalancedResult, totalDayNum))
        else:
            logging.debug('empty unbalanceResult')
            scheduleResult.message = u'没有找到符合条件的排班方案,建议调整参数'

        return scheduleResult
    def schedule(self, totalScheduleDays):
        scheduleResult = ScheduleResult()
        totalScheduleDays = int(totalScheduleDays)
        if totalScheduleDays % 7 != 0:
            print('totalScheduleDays % 7 != 0')
            scheduleResult.message = u'排班周期必须为7的倍数'
            return scheduleResult
        if self.totalWorkerNum < self.workerNumRequired:
            print('worker number less than workload, cannot schedule')
            scheduleResult.message = u'总员工人数小于每天休息人数,无法排班'
            return scheduleResult
        if self.totalWorkerNum == self.workerNumRequired:
            print('worker number equals to workload, don\'t need to schedule at all')
            scheduleResult.message = u'总员工人数等于每天休息人数,无需排班'
            return scheduleResult
        if self.minRestDay > self.maxRestDay:
            print('min day > max day')
            scheduleResult.message = u'最小连续休息天数大于最大连续休息天数,无法排班'
            return scheduleResult
        try:
            [restCalendar, workStats] = self.doSchedule(totalScheduleDays)
            if not self.validateSchedule(restCalendar):
                scheduleResult.message = u'没有找到符合条件的排班方案,请调整参数'
            else:
                scheduleResult.restCalendar = restCalendar
                scheduleResult.workCalendar = self.getWorkCalendar(restCalendar)
                scheduleResult.personalTotalWorkDay = self.calculateWorkDayPerWorker(scheduleResult.workCalendar)
                scheduleResult.message = u'排班成功'
        except:
            scheduleResult.message = u'遇到未知错误,没有找到符合条件的排班方案,请调整参数'

        return scheduleResult
    def schedule(self, targetDays):
        scheduleResult = ScheduleResult()
        targetDays = int(targetDays)
        if len(self.workers) < self.workload:
            print('worker number less than workload, cannot schedule')
            scheduleResult.message = u'总员工人数小于每天出勤人数,无法排班'
            return scheduleResult
        if len(self.workers) == self.workload:
            print('worker number equals to workload, don\'t need to schedule at all')
            scheduleResult.message = u'总员工人数等于每天出勤人数,无需排班'
            return scheduleResult
        if self.minWorkDay > self.maxWorkDay:
            print('min day > max day')
            scheduleResult.message = u'最小连续出勤天数大于最大连续出勤天数,无法排班'
            return scheduleResult
        if self.minWorkDay == self.maxWorkDay:
            if len(self.workers) < self.workload * 2:
                print('min=max but workers < workload * 2, not enough worker to handle the workload')
                scheduleResult.message = u'最大最小连续出勤数相等且总员工数小于每天出勤人数的两倍,人手不足'
                return scheduleResult
            else:
                # 固定班次的话,则误差可能为固定连续出勤数
                self.MAX_DELTA_DAY = self.minWorkDay
        # 这种情况包含了上一种情况
        if len(self.workers) < self.workload * 2:
            if self.maxWorkDay < self.minWorkDay * 2:
                print('min * 2 > max while workers < workload * 2, not enough worker to handle the workload')
                scheduleResult.message = u'总员工数小于每天出勤人数的两倍,且最大连续出勤天数小于最小连续出勤天数的两倍,人手不足'
                return scheduleResult
        workerNum = len(self.workers)
        # 平均工时每人(天),向上取整
        targetTotalWorkDay = int(targetDays * self.workload + workerNum - 1) / workerNum

        if self.minWorkDay > targetTotalWorkDay:
            scheduleResult.message = u'最小连续工时大于平均工时,不能平均安排工时'
            return scheduleResult

        retryCnt = 0
        minDelta = 99999
        unBalancedResult = dict()
        while retryCnt < self.MAX_RETRY_TIME:
            retryCnt += 1
            [resultCalendar, workStats] = self.doSchedule(targetDays)
            # self.printSchedule(resultCalendar)
            if self.validateSchedule(resultCalendar):
                currentDelta = self.getMaxDelta(resultCalendar, targetDays)
                if currentDelta <= self.MAX_DELTA_DAY:
                    print('after', retryCnt, 'time\'s retry')
                    self.printSchedule(resultCalendar)
                    scheduleResult.message = u'排班成功且工时较为平均'
                    scheduleResult.workCalendar = resultCalendar
                    scheduleResult.personalTotalWorkDay = self.calculateWorkDayPerWorker(resultCalendar)
                    scheduleResult.restCalendar = self.getRestCalendar(resultCalendar)
                    # scheduleResult.workStats = workStats
                    return scheduleResult
                else:
                    # 如果不够平均,则取目前最平均的排班返回
                    print('minDelta', minDelta, 'current', currentDelta)
                    if minDelta > currentDelta:
                        unBalancedResult = resultCalendar
                        unBalancedWorkStats = workStats
                        minDelta = currentDelta

        print('fail to schedule after', self.MAX_RETRY_TIME, 'retries')
        if unBalancedResult:
            # print('before rebalance'
            # print('delta', self.getMaxDelta(unBalancedResult, targetDays)
            # print(self.calculateWorkDayPerWorker(unBalancedResult)
            # self.printSchedule(unBalancedResult)
            newUnBalancedResult = self.rebalance(unBalancedResult, unBalancedWorkStats)
            # print('revalidate', self.validateSchedule(newUnBalancedResult)
            # print('after rebalance'
            # print('new delta', self.getMaxDelta(newUnBalancedResult, targetDays)
            # print(self.calculateWorkDayPerWorker(newUnBalancedResult)
            # self.printSchedule(newUnBalancedResult)
            if (self.validateSchedule(newUnBalancedResult)):
                scheduleResult.message = u'排班成功但没有找到工时最平均方案'
                scheduleResult.workCalendar = newUnBalancedResult
                scheduleResult.personalTotalWorkDay = self.calculateWorkDayPerWorker(newUnBalancedResult)
                scheduleResult.restCalendar = self.getRestCalendar(newUnBalancedResult)
                # scheduleResult.workStats = unBalancedWorkStats
            else:
                scheduleResult.message = u'尝试重新平衡化工时失败,如果不满意请重试'
                scheduleResult.workCalendar = unBalancedResult
                scheduleResult.personalTotalWorkDay = self.calculateWorkDayPerWorker(unBalancedResult)
                scheduleResult.restCalendar = self.getRestCalendar(unBalancedResult)
                # scheduleResult.workStats = unBalancedWorkStats
        else:
            print('empty unbalanceResult')
            scheduleResult.message = u'没有找到符合条件的排班方案,请调整参数'

        self.printFormatedCalendar(scheduleResult.workCalendar)
        self.getMaxDelta(scheduleResult.workCalendar, targetDays)

        return scheduleResult