#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 22 10:41:59 2019

@author: andrea
"""

import immagini

class Colore:
        
    def __init__(self, r=0, g=0, b=0):
        self.r = r
        self.g = g
        self.b = b
    
    def __repr__(self):
        return f"Colore({self.r}, {self.g}, {self.b})"

    def __eq__(self, other):
        return type(other) == Colore and (self.r, self.g, self.b) == (other.r, other.g, other.b)

    def asTripla(self):
        "torna la terna di valori (R, G, B) di questo colore"
        return (max(0,min(255, round(self.r))), 
                max(0,min(255, round(self.g))), 
                max(0,min(255, round(self.b))))

    def inverso(self):
        "torna il colore negativo/complementare"
        return Colore.BIANCO - self

    # amplifico la distanza di un colore dal grigio
    def contrasto(self, fattore):
        return Colore.GRIGIO + ((self - Colore.GRIGIO)*fattore)

    # moltiplico un colore per un fattore
    def __mul__(self, fattore):
        return Colore(self.r*fattore, self.g*fattore, self.b*fattore)

    # sommo due colori
    def __add__(self,other):
        return Colore(self.r+other.r, self.g+other.g, self.b+other.b)

    # sottraggo due colori
    def __sub__(self,other):
        return Colore(self.r-other.r, self.g-other.g, self.b-other.b)


Colore.BIANCO = Colore(255, 255, 255)
Colore.NERO   = Colore()
Colore.ROSSO  = Colore(255, 0, 0)    
Colore.GRIGIO = Colore.BIANCO * 0.5


class Immagine:
    
    def __init__(self, W, H, color=Colore()):
        self.larghezza = W
        self.altezza   = H
        self.img       = [  [color]*W
                            for _ in range(H)
                            ]

    def __repr__(self):
        return f"Immagine({self.larghezza}, {self.altezza})"

    def asTriple(self):
        "torna una lista di liste di triple da salvare con immagini.save"
        return [ [ c.asTripla() for c in riga  ]
                for riga in self.img]

    def save(self, filename):
        # prima trasformo l'immagine da lista di liste di Colore a lista di liste di triple
        triple = self.asTriple()
        immagini.save(triple, filename)
        
    
    def load(self, filename):
        lista_di_liste_di_triple = immagini.load(filename) 
        self.larghezza = len(lista_di_liste_di_triple[0])
        self.altezza   = len(lista_di_liste_di_triple)
        self.img = [
                    [ Colore(r,g,b) for r,g,b in riga  ]
                    for riga in lista_di_liste_di_triple
                ]


    def contrasto(self, fattore):
        nuova = Immagine(self.larghezza, self.altezza)
        for x in range(self.larghezza):
            for y in range(self.altezza):
                nuova.img[y][x] = self.img[y][x].contrasto(fattore)
        return nuova


# fattoriale(N) ricorsivo
def fatt(N):
    if N == 1:
        return 1
    else:
        return N*fatt(N-1)

def stampaR(L):
    if len(L)==0:
        pass
    else:
        print(L[0])
        stampaR(L[1:])

def stampaRovescio(L):
    if len(L)==0:
        pass
    else:
        stampaRovescio(L[1:])
        print(L[0])


def sommaRicorsiva(L):
    if len(L) == 0:
        return 0
    else:
        return L[0] + sommaRicorsiva(L[1:])

def sommaR_con_indice(L, i=0):
    "torna la somma degli elementi di L a partire dall'indice i"
    if i == len(L):
        return 0
    else:
        return L[i] + sommaR_con_indice(L, i+1)