"""
###############################################################################
PyClock 3.0: a clock GUI in Python/tkinter.

[SA] Sep-2017: Standalone release of PyCalc, PyClock, PyPhoto, PyToe.
Copyright 2017 M.Lutz, from book "Programming Python, 4th Edition".
License: provided freely, but with no warranties of any kind.

With both analog and digital display modes, a pop-up date label, clock face 
images, general resizing, countdown loops, etc.  May be run both standalone, 
or embedded (attached) in other GUIs that need a clock display.

New in 2.0: s/m keys set seconds/minutes timer for pop-up msg; window icon.
New in 2.1: updated to run under Python 3.X (2.X no longer supported).
New in 3.0 [SA]: Mac OS port, '?' help, new configs, app+exes, PIL option.
TBD: requiring PIL or Tk 8.6+ would allow other types of images besides GIF.
###############################################################################
"""

from tkinter import *
from tkinter.simpledialog import askinteger
import math, time, sys

trace = lambda *args: None   # or print
RunningOnMac     = sys.platform.startswith('darwin')   # [SA] Mac port
RunningOnWindows = sys.platform.startswith('win')      # [SA] Win backpot

# [SA] use PIL iff present
pillowwarning = """
Pillow 3rd-party package is not installed.
...This package is optional, but required for the clock images feature when
...using some image file types and Pythons (though not for GIFs with any Python,
...or PNGs with Pythons that use Tk 8.6 or later, including standard Windows 
...installs of Python 3.4+).  Pillow home: https://pypi.python.org/pypi/Pillow.
"""

try:
    from PIL.ImageTk import PhotoImage   # replace tkinter's version
except ImportError:
    from tkinter import PhotoImage       # else use the basic lib version
    print(pillowwarning)
    # but continue: falls back on Tk/tkinter's native PhotoImage, for PNGs, GIFs, etc.
    # Pillow install is required for source-code only: apps/exes have it "baked in"

# [SA]: set window icons on Windows and Linux
from windowicons import trySetWindowIcon


###############################################################################
# Option configuration classes and arg parser
###############################################################################

# [SA] DEFUNCT: now loaded from file or args


###############################################################################
# Digital display object
###############################################################################

class DigitalDisplay(Frame):
    def __init__(self, parent, cfg):          # [SA] tbd: help here too?
        Frame.__init__(self, parent)
        self.hour = Label(self)
        self.mins = Label(self)
        self.secs = Label(self)
        self.ampm = Label(self)
        for label in self.hour, self.mins, self.secs, self.ampm:
            label.config(bd=4, relief=SUNKEN, bg=cfg.BgColor, fg=cfg.FgColor)
            label.pack(side=LEFT)  # TBD: could expand, and scale font on resize

        # [SA] yes, make frame expandable; else tiny if window grows for digital
        for widget in (self, self.hour, self.mins, self.secs, self.ampm):
            widget.pack(expand=YES, fill=BOTH)

    def onUpdate(self, hour, mins, secs, ampm, cfg):
        mins = str(mins).zfill(2)                          # or '%02d' % x
        self.hour.config(text=str(hour), width=4)
        self.mins.config(text=str(mins), width=4)
        self.secs.config(text=str(secs), width=4)
        self.ampm.config(text=str(ampm), width=4)

    def onResize(self, newWidth, newHeight, cfg):
        pass  # nothing to redraw here


###############################################################################
# Analog display object
###############################################################################

class AnalogDisplay(Canvas):
    def __init__(self, parent, cfg):
        self.size = int(cfg.InitialSize.split('x')[0])   # [SA] one: square
        Canvas.__init__(self, parent,
                        width=self.size, height=self.size, bg=cfg.BgColor)
        self.parent = parent
        self.drawClockface(cfg)
        self.hourHand = self.minsHand = self.secsHand = self.cog = None

    def drawClockface(self, cfg):                         # on start and resize
        if cfg.PictureFile:                               # draw ovals, picture
            try:
                self.image = PhotoImage(file=cfg.PictureFile)      # bkground
            except:
                self.image = BitmapImage(file=cfg.PictureFile)     # save ref
            imgx = (self.size - self.image.width())  // 2          # center it
            imgy = (self.size - self.image.height()) // 2          # 3.x // div
            self.create_image(imgx+1, imgy+1,  anchor=NW, image=self.image)
        originX = originY = radius = self.size // 2                # 3.x // div
        for i in range(60):
            x, y = self.point(i, 60, radius-6, originX, originY)
            self.create_rectangle(x-1, y-1, x+1, y+1, fill=cfg.FgColor)   # mins
        for i in range(12):
            x, y = self.point(i, 12, radius-6, originX, originY)
            self.create_rectangle(x-3, y-3, x+3, y+3, fill=cfg.FgColor)   # hours
        self.ampm = self.create_text(3, 3, anchor=NW, fill=cfg.FgColor)

        # [SA] add a help popup via '?' click
        help = Button(self.master, text='?', command=self.parent.onHelp, fg=cfg.FgColor)
        self.create_window(self.size+1, 0, window=help, anchor=NE)
        if RunningOnWindows:
            help.bind('<Button-1>', lambda event: self.parent.onHelp)   # else ~ canvas

    def point(self, tick, units, radius, originX, originY):
        angle = tick * (360.0 / units)
        radiansPerDegree = math.pi / 180
        pointX = int( round( radius * math.sin(angle * radiansPerDegree) ))
        pointY = int( round( radius * math.cos(angle * radiansPerDegree) ))
        return (pointX + originX+1), (originY+1 - pointY)

    def onUpdate(self, hour, mins, secs, ampm, cfg):        # on timer callback
        if self.cog:                                        # redraw hands, cog
            self.delete(self.cog)
            self.delete(self.hourHand)
            self.delete(self.minsHand)
            self.delete(self.secsHand)
        originX = originY = radius = self.size // 2         # 3.x div
        hour = hour + (mins / 60.0)
        hx, hy = self.point(hour, 12, (radius * .80), originX, originY)
        mx, my = self.point(mins, 60, (radius * .90), originX, originY)
        sx, sy = self.point(secs, 60, (radius * .95), originX, originY)
        self.hourHand = self.create_line(originX, originY, hx, hy,
                             width=(self.size * .04),
                             arrow='last', arrowshape=(25,25,15), fill=cfg.HhColor)
        self.minsHand = self.create_line(originX, originY, mx, my,
                             width=(self.size * .03),
                             arrow='last', arrowshape=(20,20,10), fill=cfg.MhColor)
        self.secsHand = self.create_line(originX, originY, sx, sy,
                             width=1,
                             arrow='last', arrowshape=(5,10,5), fill=cfg.ShColor)
        cogsz = self.size * .01
        self.cog = self.create_oval(originX-cogsz, originY+cogsz,
                                    originX+cogsz, originY-cogsz, fill=cfg.CogColor)
        self.dchars(self.ampm, 0, END)
        self.insert(self.ampm, END, ampm)

    def onResize(self, newWidth, newHeight, cfg):
        newSize = min(newWidth, newHeight)
        #print('analog onResize', self.size+4, newSize)
        if newSize != self.size+4:
            self.size = newSize-4
            self.delete('all')
            self.drawClockface(cfg)   # onUpdate will be run next, after this 


###############################################################################
# Clock composite object
###############################################################################

ChecksPerSec = 10  # second change timer

class Clock(Frame):
    def __init__(self, configs=object(), parent=None):
        Frame.__init__(self, parent)
        self.root = parent                           # [SA] for focus force
        self.cfg = configs
        self.makeWidgets(parent)                     # children are packed but
        self.labelOn = 0                             # clients pack or grid me
        self.display = self.digitalDisplay
        self.lastSec = self.lastMin = -1
        self.countdownSeconds = 0
        self.onSwitchMode(None)                      # flip to draw analog now 
        self.onToggleLabel(None)                     # [SA] label starts on
        self.onTimer()

    def makeWidgets(self, parent):
        self.digitalDisplay = DigitalDisplay(self, self.cfg)
        self.analogDisplay  = AnalogDisplay(self,  self.cfg)
        self.dateLabel      = Label(self, bd=3) 
        # [SA] default colors (or bg='black', fg='white' (but not red/blue from PP4E))
 
        if not RunningOnMac:
            # original code: Windows, Linux
            parent.bind('<ButtonPress-1>', self.onSwitchMode)    # leftclick
            parent.bind('<ButtonPress-3>', self.onToggleLabel)   # rightclick

        else:
            # [SA] on Mac OS, can't bind B1 to root window, else fires 
            # on window moves (i.e., border clicks); also use B2 instead 
            # of B3 for right-click, and allow Control-B1 as a synonym;
            #
            parent.bind('<KeyPress-x>',            self.onSwitchMode)
            parent.bind('<ButtonPress-2>',         self.onToggleLabel)
            parent.bind('<Control-ButtonPress-1>', self.onToggleLabel)

        parent.bind('<Configure>',  self.onResize)
        parent.bind('<KeyPress-s>', self.onCountdownSec)
        parent.bind('<KeyPress-m>', self.onCountdownMin)

    def onSwitchMode(self, event):
        trace('onSwitchMode', self.display.__class__.__name__)
        self.display.pack_forget()
        if self.display == self.analogDisplay:
            self.display = self.digitalDisplay
        else:
            self.display = self.analogDisplay
        self.display.pack(side=TOP, expand=YES, fill=BOTH)

    def onToggleLabel(self, event):
        self.labelOn += 1
        if self.labelOn % 2:
            self.dateLabel.pack(side=BOTTOM, fill=X)
        else:
            self.dateLabel.pack_forget()
        self.update()

    def onResize(self, event):
        if event.widget == self.display:
            trace('onResize', event.widget.__class__.__name__)
            self.display.onResize(event.width, event.height, self.cfg)

    def onTimer(self):
        secsSinceEpoch = time.time()
        timeTuple      = time.localtime(secsSinceEpoch)
        hour, min, sec = timeTuple[3:6]
        if sec != self.lastSec:
            self.lastSec = sec
            ampm = ((hour >= 12) and 'PM') or 'AM'               # 0...23
            hour = (hour % 12) or 12                             # 12..11
            self.display.onUpdate(hour, min, sec, ampm, self.cfg)

            # [SA] better time label format
            #self.dateLabel.config(text=time.ctime(secsSinceEpoch))
            timeFormat = '%a %b %d, %Y %X'
            self.dateLabel.config(text=time.strftime(timeFormat, timeTuple))
       
            self.countdownSeconds -= 1
            if self.countdownSeconds == 0:
                self.onCountdownExpire()                # countdown timer
        self.after(1000 // ChecksPerSec, self.onTimer)  # run N times per second
                                                        # 3.x // trunc int div
    def onCountdownSec(self, event):
        secs = askinteger('Countdown', 'Seconds?')
        if secs: self.countdownSeconds = secs

    def onCountdownMin(self, event):
        secs = askinteger('Countdown', 'Minutes')
        if secs: self.countdownSeconds = secs * 60

    def onCountdownExpire(self):
        # caveat: only one active, no progress indicator
        win = Toplevel()
        if RunningOnMac:
            # [SA] emulate colored buttons on Mac
            msg = Label(win, text='Timer Expired!')
            msg.bind('<Button-1>', lambda e: win.destroy())
        else:
            msg = Button(win, text='Timer Expired!', command=win.destroy)
        msg.config(font=('courier', 80, 'normal'), fg='white', bg='navy')
        msg.config(padx=10, pady=10)
        msg.pack(expand=YES, fill=BOTH)
        win.lift()                             # raise above siblings
        if sys.platform[:3] == 'win':          # full screen on Windows
            win.state('zoomed')
        elif RunningOnMac:                     # [SA] Mac is different...
            win.wm_attributes('-fullscreen', 1)

    def onHelp(self):
        # [SA] clock display's '?' help callback
        from tkinter.messagebox import showinfo
        showinfo('PyClock Help', 
                 'PyClock 3.0\n'
                 '\n'
                 'A Python/tkinter clock GUI.\n'
                 'For Mac OS, Windows, and Linux.\n'
                 'From the book Programming Python.\n'
                 'Author and © M. Lutz 2001-2017.\n'
                 '\n'
                 'Usage:\n'
                 '▶ Leftclick (key "X" on Macs) switches between analog and '
                 'digital displays \n'
                 '▶ Rightclick (2-finger press or control+click '
                 'on Macs) shows/hides date label\n'
                 '▶ Keys "S" and "M" start seconds and minutes timers, respectively\n'
                 '▶ Resizing the window resizes the current clock display.\n'
                 '\n'
                 'Clock photos: analog clocks in app and executable '
                 'PyClocks support all common image types.  For source-code, '
                 'GIF always works, PNG works for Tk 8.6+, and all types '
                 'work after Pillow install (see README.txt).\n'
                 '\n'
                 'Version history:\n'
                 '● 3.0: Sep 2017, standalone release\n'
                 '● 2.1: May 2010, Programming Python 4E\n'
                 '● 2.0: 2006 PP3E, 1.0: 2001 PP2E\n'
                 '\n'
                 'For downloads and more apps, visit:\n'
                 'http://learning-python.com/programs.html'
                )
        if self.root: self.root.focus_force()   # [SA] for Mac


###############################################################################
# Standalone clocks
###############################################################################

appname = 'PyClock 3.0'


# use new custom Tk, Toplevel for icons, etc.
from PP4E.Gui.Tools.windows import PopupWindow, MainWindow


class ClockPopup(PopupWindow):
    def __init__(self, configs=object(), name=''):
        PopupWindow.__init__(self, appname, name)
        clock = Clock(configs, self)
        clock.pack(expand=YES, fill=BOTH)


class ClockMain(MainWindow):
    def __init__(self, configs=object(), name=''):
        MainWindow.__init__(self, appname, name)
        clock = Clock(configs, self)
        clock.pack(expand=YES, fill=BOTH)
        self.clock = clock


# b/w compat: manual window borders, passed-in parent

class ClockWindow(Clock):
    def __init__(self, config=object(), parent=None, name=''):
        Clock.__init__(self, configs, parent)
        self.pack(expand=YES, fill=BOTH)
        title = appname
        if name: title = appname + ' - ' + name
        self.master.title(title)                # master=parent or default
        self.master.protocol('WM_DELETE_WINDOW', self.quit)


###############################################################################
# Program run
###############################################################################

if __name__ == '__main__':
    from getConfigs import getConfigs      # [SA] new common gadgets utility
    defaults = dict(InitialSize='200x200', 
                    BgColor='beige',       # canvas
                    FgColor='brown',       # ticks 
                    HhColor='black',       # hour hand
                    MhColor='navy',        # minute hand
                    ShColor='blue',        # second hand
                    CogColor='white' ,     # center point
                    PictureFile=None)      # middle photo path
    configs = getConfigs('PyClock', defaults)   # load from file or args

    # alternatives
    #myclock = ClockWindow(Tk(), configs)
    #myclock = ClockPopup('popup', configs)

    # parent is Tk root if standalone
    myclock = ClockMain(configs)
    trySetWindowIcon(myclock, 'icons', 'pygadgets')   # [SA] for win+lin

    if RunningOnMac:
        # Mac requires menus, deiconifies, focus

        # [SA] on Mac, customize app-wide automatic top-of-display menu
        from guimaker_pp4e import fixAppleMenuBar
        fixAppleMenuBar(window=myclock,
                        appname='PyClock',
                        helpaction=myclock.clock.onHelp,
                        aboutaction=None,
                        quitaction=myclock.quit)    # app-wide quit: ask

        # [SA] reopen auto on dock/app click and fix tk focus loss on deiconify
        def onReopen():
            myclock.lift()
            myclock.update()
            temp = Toplevel()
            temp.lower()
            temp.destroy()
        myclock.createcommand('::tk::mac::ReopenApplication', onReopen)

    myclock.mainloop()