#! /usr/gitea.inhome.blapointe.com/local/bin/python3

def main(args) :
   print("args", args)
   for i in args :
      rotate(i)

def rotate(x) :
   print("input: {}", x)
   rgb = hex_to_rgb(x)
   print("rgb:   {}", rgb)
   hsl = rgb_to_hsl(rgb)
   print("hsl:   {}", hsl)
   import os
   env = os.environ
   if "DEG" in env :
      deg = int(env["DEG"])
   else :
      deg = 110
   hsl = rotate_hsl(hsl, deg)
   print("hsl':  {}", hsl)
   rgb = hsl_to_rgb(hsl)
   print("rgb':  {}", rgb)
   print(rgb_to_hex(rgb))

def hex_to_rgb(x) :
   if x.startswith("#") :
      x = x[1:]
   r = x[0:2]
   g = x[2:4]
   b = x[4:6]
   return (
      hex_to_dec(r),
      hex_to_dec(g),
      hex_to_dec(b),
   )

def hex_to_dec(x) :
   s = 0
   mul = 1
   for i in range(len(x)):
      c = x[len(x)-i-1]
      c = c.upper()
      digit = ord(c) - ord('0')
      if not c.isdigit() :
         digit = ord(c) - ord('A') + 10
      s += mul * digit
      mul *= 16
   return s

def rgb_to_hsl(rgb) :
   return (
       compute_h(rgb),
       compute_s(rgb),
       compute_l(rgb),
   )

def compute_h(rgb) :
   r, g, b, cmax, cmin, delta = compute_hsl_const(rgb)
   if delta == 0 :
      return 0
   if r == cmax :
      return 60 * ( ( (g - b)/delta ) % 6)
   if g == cmax :
      return 60 * ( ( (b - r)/delta ) + 2)
   if b == cmax :
      return 60 * ( ( (r - g)/delta ) + 4)

def compute_s(rgb) :
   r, g, b, cmax, cmin, delta = compute_hsl_const(rgb)
   if delta == 0 :
      return 0
   return delta / ( 1 - (abs(2*compute_l(rgb)-1)) )

def compute_l(rgb) :
   r, g, b, cmax, cmin, delta = compute_hsl_const(rgb)
   return (cmax + cmin) / 2

def compute_hsl_const(rgb) :
   rgb = [ i/255.0 for i in rgb ]
   return rgb[:] + [max(rgb), min(rgb), max(rgb)-min(rgb)]

def rotate_hsl(hsl, deg) :
   return (
      (hsl[0] + deg) % 360,
      hsl[1],
      hsl[2],
   )

def hsl_to_rgb(hsl) :
   h = hsl[0]
   s = hsl[1]
   l = hsl[2]

   c = s * (1 - abs(2 * l))
   x = c * (1 - abs((h / 60) % 2 - 1))
   m = l - (c / 2)

   rgbp = ()
   if h < 60 :
      rgbp = (c, x, 0)
   if h < 120 :
      rgbp = (x, c, 0)
   if h < 180 :
      rgbp = (0, c, x)
   if h < 240 :
      rgbp = (0, x, c)
   if h < 300 :
      rgbp = (x, 0, c)
   else:
      rgbp = (c, 0, x)

   r = rgbp[0]
   g = rgbp[1]
   b = rgbp[2]
   return (
      (r+m)*255,
      (g+m)*255,
      (b+m)*255,
   )

def rgb_to_hex(rgb) :
   r = min(max(int(rgb[0]), 0), 255)
   g = min(max(int(rgb[1]), 0), 255)
   b = min(max(int(rgb[2]), 0), 255)
   return "#{:02x}{:02x}{:02x}".format(r, g, b)

from sys import argv
main(argv[1:])