# -*- coding: latin1 -*- 
import math

class uneFigure: # devrait être abstraite
  def __init__(self, x, y):
    self.x = x
    self.y = y
  def __repr__(self):
    output = "Je suis %s" % self.libelleNature()
    output += "\n%s est en (%s,  %s)" % (self.libelleReference(), self.x, self.y)
    output += "\n%s vaut %s" % (self.libelleTaille(), self.maTaille())
    return output
  def libelleNature(self):
    return "une figure"
  def libelleReference(self):
    return "Mon point de référence"
  def libelleTaille(self):
    return "Ma taille"
  def maTaille(self):
    return -1 # devrait être abstraite

class uneFigurePlane(uneFigure): # devrait être abstraite
  def __init__(self, x, y):
    uneFigure.__init__(self, x, y) # aurait dû s'écrire : super().__init__(x, y)
    #                                                  ou super(uneFigurePlane, self).__init__(x, y)
  def libelleNature(self):
    return "une figure plane"
  def libelleTaille(self):
    return "Ma surface"
  def maTaille(self):
    return self.maSurface()
  def maSurface(self):
    return -2 # devrait être abstraite

class unCercle(uneFigurePlane):
  def __init__(self, x, y, r):
    uneFigurePlane.__init__(self, x, y)
    self.r = r
  def libelleNature(self):
    return "un cercle"
  def libelleReference(self):
    return "Mon centre"
  def maSurface(self):
    return math.pi * self.r * self.r
  def __repr__(self):
    output = super().__repr__()
    output += "\nMon rayon vaut %s" % self.r
    return output
  
class unRectangle(uneFigurePlane):
  def __init__(self, x, y, h, l):
    uneFigurePlane.__init__(self, x, y)
    self.h = h
    self.l = l
  def libelleNature(self):
    return "un rectangle"
  def libelleReference(self):
    return "Mon coin inférieur gauche"
  def maSurface(self):
    return self.h * self.l
  def __repr__(self):
    output = super().__repr__()
    output += "\n%s" % self.hauteurLargeur()
    return output
  def hauteurLargeur(self):
    output = "Ma hauteur vaut %s" % self.h
    output += "\nMa largeur vaut %s" % self.l
    return output

class unCarre(unRectangle):
  def __init__(self, x, y, c):
    unRectangle.__init__(self, x, y, c, c)
  def libelleNature(self):
    return "un carré"
  def hauteurLargeur(self):
    output = "Mon coté vaut %s" % self.h
    return output

class unPoint(uneFigure):
  def __init__(self, x, y):
    uneFigure.__init__(self, x, y)
  def libelleNature(self):
    return "un point"
  def libelleReference(self):
    return "Ma position"
  def maTaille(self):
    return 0
  
class uneFigurePesante(uneFigure): # devrait être abstraite
  def __init__(self, x, y, d):
    uneFigure.__init__(self, x, y)
    self.d = d
  def libelleNature(self):
    return "une figure pesante"
  def monPoids(self):
    return self.d * self.maTaille()
  def __repr__(self):
    output = super().__repr__()
    output += "\nMon poids vaut %s" % self.monPoids()
    output += "\nMa densite vaut %s" % self.d
    return output

class unCerclePesant(unCercle, uneFigurePesante):
  def __init__(self, x, y, r, d):
    unCercle.__init__(self, x, y, r)
    uneFigurePesante.__init__(self, x, y, d)
  def libelleNature(self):
    return "un cercle pesant"

class unCarreEvideParUnCercle1(unCarre):
  def __init__(self, x, y, c, r):
    unCarre.__init__(self, x, y, c)
    self.r = r
  def libelleNature(self):
    return "un carré évidé par un cercle"
  def maSurface(self):
    return super().maSurface() - math.pi * self.r * self.r
  def __repr__(self):
    output = super().__repr__()
    output += "\nLe rayon du cercle qui m'évide vaut %s" % self.r
    return output

class uneFigurePlaneEvideeParFigurePlane(uneFigurePlane):
  def __init__(self, exterieur, interieur):
    uneFigurePlane.__init__(self, exterieur.x, exterieur.y)
    self.exterieur = exterieur
    self.interieur = interieur
  def libelleNature(self):
    return "%s évidé(e) par %s" % (self.exterieur.libelleNature(), self.interieur.libelleNature())
  def maSurface(self):
    return self.exterieur.maSurface()-self.interieur.maSurface()
  def __repr__(self):
    output = super().__repr__()
    output += "\nMa figure extérieure : [%s]" % self.exterieur
    output += "\nMa figure intérieure : [%s]" % self.interieur
    return output

class unCarreEvideParUnCercle2(uneFigurePlaneEvideeParFigurePlane):
  def __init__(self, x, y, c, r):
    uneFigurePlaneEvideeParFigurePlane.__init__(self, unCarre(x, y, c), unCercle(x+c/2, y+c/2, r))

for f in [uneFigure(-1, 1), uneFigurePlane(1,2), unCercle(0,0,2), unRectangle(1,-1,3,2), unCarre(1,2,3),\
          unPoint(0,0), \
          uneFigurePesante(2,2,3), unCerclePesant(-2,-1,2,4), \
          unCarreEvideParUnCercle1(-1, -1, 2, 0.5), unCarreEvideParUnCercle2(-1, -1, 2, 0.5)]:
  print(f)
  print()