from cubicweb.web import INTERNAL_FIELD_VALUE, RequestError, NothingToEdit, ProcessFormError

class RqlQuery(object):

    def __init__(self):

        self.edited = []

        self.restrictions = []

        self.kwargs = {}

    def insert_query(self, etype):

        if self.edited:

            rql = 'INSERT %s X: %s' % (etype, ','.join(self.edited))

        else:

            rql = 'INSERT %s X' % etype

        if self.restrictions:

            rql += ' WHERE %s' % ','.join(self.restrictions)

        return rql

    def update_query(self, eid):

        varmaker = rqlvar_maker()

        var = varmaker.next()

        while var in self.kwargs:

            var = varmaker.next()

        rql = 'SET %s WHERE X eid %%(%s)s' % (','.join(self.edited), var)

        if self.restrictions:

            rql += ', %s' % ','.join(self.restrictions)

        self.kwargs[var] = eid

        return rql

        self.errors = []

        self.relations_rql = []

            methodname = req.form.pop('__method', None)

            if '__linkto' in req.form and 'eid' in req.form:

            elif not ('__delete' in req.form or '__insert' in req.form or todelete or toinsert):

        for querydef in self.relations_rql:

            self.req.execute(*querydef)

        # XXX find a way to merge _pending_relations and relations_rql

            for form, field, entity in self._pending_relations:

                for querydef in self.handle_relation(form, field, entity, True):

                    self.req.execute(*querydef)

        if req.form.has_key('__insert'):

            toinsert = req.list_form_param('__insert', req.form, pop=True)

    def _insert_entity(self, etype, eid, rqlquery):

        rql = rqlquery.insert_query(etype)

        try:

            # get the new entity (in some cases, the type might have

            # changed as for the File --> Image mutation)

            entity = self.req.execute(rql, rqlquery.kwargs).get_entity(0, 0)

            neweid = entity.eid

        except ValidationError, ex:

            self._to_create[eid] = ex.entity

            if self.req.json_request: # XXX (syt) why?

                ex.entity = eid

            raise

        self._to_create[eid] = neweid

        return neweid

    def _update_entity(self, eid, rqlquery):

        rql = rqlquery.update_query(eid)

        self.req.execute(rql, rqlquery.kwargs)

        entity.eid = formparams['eid']

        eid = self._get_eid(entity.eid)

        # let a chance to do some entity specific stuff.tn

        rqlquery = RqlQuery()

        # this will generate less rql queries and might be useful in

        # a few dark corners

        formid = self.req.form.get('__form_id', 'edition')

        form = self.vreg['forms'].select(formid, self.req, entity=entity)

        for field in form.fields:

            if form.form_field_modified(field):

                self.handle_formfield(form, field, entity, rqlquery)

            entity.eid = self._insert_entity(etype, formparams['eid'], rqlquery)

        elif rqlquery.edited: # edition of an existant entity

            self._update_entity(eid, rqlquery)

    def handle_formfield(self, form, field, entity, rqlquery):

        eschema = entity.e_schema

        try:

            for attr, value in field.process_posted(form):

                if not (

                    (field.role == 'subject' and eschema.has_subject_relation(field.name))

                    or

                    (field.role == 'object' and eschema.has_object_relation(field.name))):

                    continue

                rschema = self.schema.rschema(field.name)

                if rschema.is_final():

                    rqlquery.kwargs[attr] = value

                    rqlquery.edited.append('X %s %%(%s)s' % (attr, attr))

                elif rschema.inlined:

                    self.handle_inlined_relation(form, field, entity, rqlquery)

                else:

                    self.relations_rql += self.handle_relation(

                        form, field, entity)

        except ProcessFormError, exc:

            self.errors.append((field, exc))

    def _relation_values(self, form, field, entity, late=False):

        """handle edition for the (rschema, x) relation of the given entity

        values = set()

        for eid in field.process_form_data(form):

            if not eid: # AutoCompletionWidget

                continue

            typed_eid = self._get_eid(eid)

            if typed_eid is None:

                if late:

                    # eid is still None while it's already a late call

                    # this mean that the associated entity has not been created

                    raise Exception("eid %s is still not created" % eid)

                self._pending_relations.append( (form, field, entity) )

                return None

            values.add(typed_eid)

        return values

    def handle_inlined_relation(self, form, field, entity, rqlquery):

        origvalues = set(row[0] for row in entity.related(field.name, field.role))

        values  = self._relation_values(form, field, entity)

        if values is None or values == origvalues:

            return # not edited / not modified / to do later

        attr = field.name

        if values:

            rqlquery.kwargs[attr] = iter(values).next()

            rqlquery.edition.append('X %s %s' % (attr, attr.upper()))

            rqlquery.restrictions.append('%s eid %%(%s)s' % (attr.upper(), attr))

        elif entity.has_eid():

            self.relations_rql += self.handle_relation(form, field, entity)

    def handle_relation(self, form, field, entity, late=False):

        origvalues = set(row[0] for row in entity.related(field.name, field.role))

        values  = self._relation_values(form, field, entity, late)

        if values is None or values == origvalues:

            return # not edited / not modified / to do later

        rschema = self.schema.rschema(field.name)

        if field.role == 'subject':

        if field.role == 'object' or not rschema.inlined or not values:

                yield (rql, {'x': eid, 'y': reid}, ('x', 'y'))

                yield (rql, {'x': eid, 'y': reid}, ('x', 'y'))