# basictimerapp - a really simple timer application.
# This should be run using the command line:
# pythonwin /app demos\basictimerapp.py
import win32ui
import win32api
import win32con
import sys
from pywin.framework import app, cmdline, dlgappcore, cmdline
import timer
import time
import string


class TimerAppDialog(dlgappcore.AppDialog):
    softspace = 1

    def __init__(self, appName=""):
        dlgappcore.AppDialog.__init__(self, win32ui.IDD_GENERAL_STATUS)
        self.timerAppName = appName
        self.argOff = 0
        if len(self.timerAppName) == 0:
            if len(sys.argv) > 1 and sys.argv[1][0] != "/":
                self.timerAppName = sys.argv[1]
                self.argOff = 1

    def PreDoModal(self):
        # 		sys.stderr = sys.stdout
        pass

    def ProcessArgs(self, args):
        for arg in args:
            if arg == "/now":
                self.OnOK()

    def OnInitDialog(self):
        win32ui.SetProfileFileName("pytimer.ini")
        self.title = win32ui.GetProfileVal(
            self.timerAppName, "Title", "Remote System Timer"
        )
        self.buildTimer = win32ui.GetProfileVal(
            self.timerAppName, "Timer", "EachMinuteIntervaler()"
        )
        self.doWork = win32ui.GetProfileVal(self.timerAppName, "Work", "DoDemoWork()")
        # replace "\n" with real \n.
        self.doWork = self.doWork.replace("\\n", "\n")
        dlgappcore.AppDialog.OnInitDialog(self)

        self.SetWindowText(self.title)
        self.prompt1 = self.GetDlgItem(win32ui.IDC_PROMPT1)
        self.prompt2 = self.GetDlgItem(win32ui.IDC_PROMPT2)
        self.prompt3 = self.GetDlgItem(win32ui.IDC_PROMPT3)
        self.butOK = self.GetDlgItem(win32con.IDOK)
        self.butCancel = self.GetDlgItem(win32con.IDCANCEL)
        self.prompt1.SetWindowText("Python Timer App")
        self.prompt2.SetWindowText("")
        self.prompt3.SetWindowText("")
        self.butOK.SetWindowText("Do it now")
        self.butCancel.SetWindowText("Close")

        self.timerManager = TimerManager(self)
        self.ProcessArgs(sys.argv[self.argOff :])
        self.timerManager.go()
        return 1

    def OnDestroy(self, msg):
        dlgappcore.AppDialog.OnDestroy(self, msg)
        self.timerManager.stop()

    def OnOK(self):
        # stop the timer, then restart after setting special boolean
        self.timerManager.stop()
        self.timerManager.bConnectNow = 1
        self.timerManager.go()
        return


# 	def OnCancel(self): default behaviour - cancel == close.
# 		return


class TimerManager:
    def __init__(self, dlg):
        self.dlg = dlg
        self.timerId = None
        self.intervaler = eval(self.dlg.buildTimer)
        self.bConnectNow = 0
        self.bHaveSetPrompt1 = 0

    def CaptureOutput(self):
        self.oldOut = sys.stdout
        self.oldErr = sys.stderr
        sys.stdout = sys.stderr = self
        self.bHaveSetPrompt1 = 0

    def ReleaseOutput(self):
        sys.stdout = self.oldOut
        sys.stderr = self.oldErr

    def write(self, str):
        s = str.strip()
        if len(s):
            if self.bHaveSetPrompt1:
                dest = self.dlg.prompt3
            else:
                dest = self.dlg.prompt1
                self.bHaveSetPrompt1 = 1
            dest.SetWindowText(s)

    def go(self):
        self.OnTimer(None, None)

    def stop(self):
        if self.timerId:
            timer.kill_timer(self.timerId)
        self.timerId = None

    def OnTimer(self, id, timeVal):
        if id:
            timer.kill_timer(id)
        if self.intervaler.IsTime() or self.bConnectNow:
            # do the work.
            try:
                self.dlg.SetWindowText(self.dlg.title + " - Working...")
                self.dlg.butOK.EnableWindow(0)
                self.dlg.butCancel.EnableWindow(0)
                self.CaptureOutput()
                try:
                    exec(self.dlg.doWork)
                    print("The last operation completed successfully.")
                except:
                    t, v, tb = sys.exc_info()
                    str = "Failed: %s: %s" % (t, repr(v))
                    print(str)
                    self.oldErr.write(str)
                    tb = None  # Prevent cycle
            finally:
                self.ReleaseOutput()
                self.dlg.butOK.EnableWindow()
                self.dlg.butCancel.EnableWindow()
                self.dlg.SetWindowText(self.dlg.title)
        else:
            now = time.time()
            nextTime = self.intervaler.GetNextTime()
            if nextTime:
                timeDiffSeconds = nextTime - now
                timeDiffMinutes = int(timeDiffSeconds / 60)
                timeDiffSeconds = timeDiffSeconds % 60
                timeDiffHours = int(timeDiffMinutes / 60)
                timeDiffMinutes = timeDiffMinutes % 60
                self.dlg.prompt1.SetWindowText(
                    "Next connection due in %02d:%02d:%02d"
                    % (timeDiffHours, timeDiffMinutes, timeDiffSeconds)
                )
        self.timerId = timer.set_timer(
            self.intervaler.GetWakeupInterval(), self.OnTimer
        )
        self.bConnectNow = 0


class TimerIntervaler:
    def __init__(self):
        self.nextTime = None
        self.wakeUpInterval = 2000

    def GetWakeupInterval(self):
        return self.wakeUpInterval

    def GetNextTime(self):
        return self.nextTime

    def IsTime(self):
        now = time.time()
        if self.nextTime is None:
            self.nextTime = self.SetFirstTime(now)
        ret = 0
        if now >= self.nextTime:
            ret = 1
            self.nextTime = self.SetNextTime(self.nextTime, now)
            # do the work.
        return ret


class EachAnyIntervaler(TimerIntervaler):
    def __init__(self, timeAt, timePos, timeAdd, wakeUpInterval=None):
        TimerIntervaler.__init__(self)
        self.timeAt = timeAt
        self.timePos = timePos
        self.timeAdd = timeAdd
        if wakeUpInterval:
            self.wakeUpInterval = wakeUpInterval

    def SetFirstTime(self, now):
        timeTup = time.localtime(now)
        lst = []
        for item in timeTup:
            lst.append(item)
        bAdd = timeTup[self.timePos] > self.timeAt
        lst[self.timePos] = self.timeAt
        for pos in range(self.timePos + 1, 6):
            lst[pos] = 0
        ret = time.mktime(tuple(lst))
        if bAdd:
            ret = ret + self.timeAdd
        return ret

    def SetNextTime(self, lastTime, now):
        return lastTime + self.timeAdd


class EachMinuteIntervaler(EachAnyIntervaler):
    def __init__(self, at=0):
        EachAnyIntervaler.__init__(self, at, 5, 60, 2000)


class EachHourIntervaler(EachAnyIntervaler):
    def __init__(self, at=0):
        EachAnyIntervaler.__init__(self, at, 4, 3600, 10000)


class EachDayIntervaler(EachAnyIntervaler):
    def __init__(self, at=0):
        EachAnyIntervaler.__init__(self, at, 3, 86400, 10000)


class TimerDialogApp(dlgappcore.DialogApp):
    def CreateDialog(self):
        return TimerAppDialog()


def DoDemoWork():
    print("Doing the work...")
    print("About to connect")
    win32api.MessageBeep(win32con.MB_ICONASTERISK)
    win32api.Sleep(2000)
    print("Doing something else...")
    win32api.MessageBeep(win32con.MB_ICONEXCLAMATION)
    win32api.Sleep(2000)
    print("More work.")
    win32api.MessageBeep(win32con.MB_ICONHAND)
    win32api.Sleep(2000)
    print("The last bit.")
    win32api.MessageBeep(win32con.MB_OK)
    win32api.Sleep(2000)


app = TimerDialogApp()


def t():
    t = TimerAppDialog("Test Dialog")
    t.DoModal()
    return t


if __name__ == "__main__":
    import demoutils

    demoutils.NeedApp()
