class as_function:
    def __init__(self, C, g):
        self.curve = C
        F = C.base_ring
        n = C.height
        RxyzQ, Rxyz, x, y, z = C.fct_field
        self.function = RxyzQ(g)
        #self.function = as_reduction(AS, RxyzQ(g))
        
    def __repr__(self):
        return str(self.function)
    
    def __eq__(self, other):
        AS = self.curve
        RxyzQ, Rxyz, x, y, z = AS.fct_field
        aux = self - other
        aux = RxyzQ(aux.function)
        aux = aux.numerator()
        aux = as_function(AS, aux)
        aux = aux.expansion_at_infty()
        F = AS.base_ring
        Rt.<t> = LaurentSeriesRing(F, default_prec=AS.prec)
        if Rt(aux).valuation() >= 1:
            return True
        return False

    def __add__(self, other):
        C = self.curve
        g1 = self.function
        g2 = other.function
        return as_function(C, g1 + g2)

    def __sub__(self, other):
        C = self.curve
        g1 = self.function
        g2 = other.function
        return as_function(C, g1 - g2)

    def __rmul__(self, constant):
        C = self.curve
        g = self.function
        return as_function(C, constant*g)
    
    def __neg__(self):
        C = self.curve
        g = self.function
        return as_function(C, -g)
    
    def __mul__(self, other):
        if isinstance(other, as_function):
            C = self.curve
            g1 = self.function
            g2 = other.function
            return as_function(C, g1*g2)
        if isinstance(other, as_form):
            C = self.curve
            g1 = self.function
            g2 = other.form
            return as_form(C, g1*g2)
    
    def __truediv__(self, other):
        C = self.curve
        g1 = self.function
        g2 = other.function
        return as_function(C, g1/g2)
    
    def __pow__(self, exponent):
        C = self.curve
        g1 = self.function
        return as_function(C, g1^(exponent))
    
    def expansion_at_infty(self, place = 0):
        C = self.curve
        delta = C.nb_of_pts_at_infty
        F = C.base_ring
        x_series = C.x_series[place]
        y_series = C.y_series[place]
        z_series = C.z_series[place]
        n = C.height
        RxyzQ, Rxyz, x, y, z = C.fct_field
        prec = C.prec
        Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
        g = self.function
        g = RxyzQ(g)
        sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)}
        return g.substitute(sub_list)
    
    def expansion(self, pt = 0):
        C = self.curve
        delta = C.nb_of_pts_at_infty
        F = C.base_ring
        x_series = C.x_series[pt]
        y_series = C.y_series[pt]
        z_series = C.z_series[pt]
        n = C.height
        RxyzQ, Rxyz, x, y, z = C.fct_field
        prec = C.prec
        Rt.<t> = LaurentSeriesRing(F, default_prec=prec)
        g = self.function
        g = RxyzQ(g)
        sub_list = {x : x_series, y : y_series} | {z[j] : z_series[j] for j in range(n)}
        return g.substitute(sub_list)

    def group_action(self, elt):
        C = self.curve
        RxyzQ, Rxyz, x, y, z = C.fct_field
        Rzf, zgen, fgen, xgen, ygen = C.cover_template.fct_field
        if isinstance(elt, group_elt):
            elt = elt.as_tuple
        AS = self.curve
        n = AS.height
        G = AS.group

        if elt in G.gens:
            ind = G.gens.index(elt)
            gp_action_list = C.cover_template.gp_action[ind]
            sub_list_gen = {zgen[i] : RxyzQ(z[i]) for i in range(n)}|{fgen[i] : RxyzQ(AS.functions[i].function) for i in range(n)}|{xgen:x}|{ygen:y}
            sub_list = {x : RxyzQ(gp_action_list[-2]), y : RxyzQ(gp_action_list[-1])} | {z[j] : RxyzQ(gp_action_list[j].subs(sub_list_gen)) for j in range(n)}
            g = self.function
            return as_function(C, g.substitute(sub_list))
        result = self
        for i in range(len(G.gens)):
            if isinstance(elt, list) or isinstance(elt, tuple): #elt can be a tuple...
                range_limit = elt[i]
            else: # ... or an integer.
                range_limit = elt
            for j in range(range_limit):
                result = result.group_action(G.gens[i])
        return result
        

    def reduce(self):
        aux = as_reduction(self.curve, self.function)
        return as_function(self.curve, aux)
    
    def trace(self, super=True, subgp = 0):
        C = self.curve
        C_super = C.quotient
        n = C.height
        F = C.base_ring
        if isinstance(subgp, Integer) or isinstance(subgp, int):
            subgp = C.group.elts
        else:
            super = False
        RxyzQ, Rxyz, x, y, z = C.fct_field
        result = as_function(C, 0)
        for a in subgp:
            result += self.group_action(a)
        result = result.function
        Rxy.<x, y> = PolynomialRing(F, 2)
        Qxy = FractionField(Rxy)
        result = as_reduction(C, result)
        if super:
            return superelliptic_function(C_super, Qxy(result))
        RxyzQ, Rxyz, x, y, z = C.fct_field
        return as_function(C, RxyzQ(result))

    def coordinates(self, prec = 100, basis = 0):
        "Return coordinates in H^1(X, OX)."
        AS = self.curve
        F = AS.base_ring
        if basis == 0:
            basis = [AS.holomorphic_differentials_basis(), AS.cohomology_of_structure_sheaf_basis()]
        holo_diffs = basis[0]
        coh_basis =  basis[1]
        f_products = []
        for f in coh_basis:
            f_products += [[omega.serre_duality_pairing(f) for omega in holo_diffs]]
        product_of_fct_and_omegas = []
        product_of_fct_and_omegas = [omega.serre_duality_pairing(self) for omega in holo_diffs]

        V = (F^(AS.genus())).span_of_basis([vector(a) for a in f_products])
        coh_coordinates = V.coordinates(product_of_fct_and_omegas)
        return coh_coordinates
    
    def diffn(self):
        C = self.curve
        C_super = C.quotient
        n = C.height
        RxyzQ, Rxyz, x, y, z = C.fct_field
        f = self.function
        y_super = superelliptic_function(C_super, y)
        dy_super = y_super.diffn().form
        dz = C.dz
        result = f.derivative(x)
        result += f.derivative(y)*dy_super
        for i in range(n):
            result += f.derivative(z[i])*dz[i]
        return as_form(C, result)
        
    def valuation(self, place = 0):
        '''Return valuation at i-th place at infinity.'''
        C = self.curve
        F = C.base_ring
        Rt.<t> = LaurentSeriesRing(F)
        return Rt(self.expansion_at_infty(place = place)).valuation()