# -*- coding: utf-8 -*-
import random
import uuid
import simplejson

import werkzeug.exceptions

from openerp import SUPERUSER_ID
from openerp.osv import osv
from openerp.addons.web import http
from openerp.addons.web.http import request
from openerp.addons.website.models import website

def get_order(order_id=None):
    order_obj = request.registry.get('sale.order')
    # check if order allready exists and have access
    if order_id:
        try:
            order = order_obj.browse(request.cr, request.uid, order_id, context=request.context)
            order.pricelist_id
            if order:
                return order
        except:
            return False

    fields = [k for k, v in order_obj._columns.items()]
    order_value = order_obj.default_get(request.cr, SUPERUSER_ID, fields, context=request.context)
    if request.httprequest.session.get('ecommerce_pricelist'):
        order_value['pricelist_id'] = request.httprequest.session['ecommerce_pricelist']
    order_value['partner_id'] = request.registry.get('res.users').browse(request.cr, SUPERUSER_ID, request.uid, context=request.context).partner_id.id
    order_value.update(order_obj.onchange_partner_id(request.cr, SUPERUSER_ID, [], order_value['partner_id'], context=request.context)['value'])

    # add website_session_id key for access rules
    if not request.httprequest.session.get('website_session_id'):
        request.httprequest.session['website_session_id'] = str(uuid.uuid4())

    order_value["website_session_id"] = request.httprequest.session['website_session_id']
    order_id = order_obj.create(request.cr, SUPERUSER_ID, order_value, context=request.context)
    order = order_obj.browse(request.cr, SUPERUSER_ID, order_id, context=request.context)
    request.httprequest.session['ecommerce_order_id'] = order.id

    return order_obj.browse(request.cr, request.uid, order_id,
                            context=dict(request.context, pricelist=order.pricelist_id.id))

def get_current_order():
    if request.httprequest.session.get('ecommerce_order_id'):
        order = get_order(request.httprequest.session.get('ecommerce_order_id'))
        if not order:
            request.httprequest.session['ecommerce_order_id'] = False
        return order
    else:
        return False

class Website(osv.osv):
    _inherit = "website"
    def preprocess_request(self, cr, uid, ids, request, context=None):
        request.context.update({
            'website_sale_order': get_current_order(),
        })
        return super(Website, self).preprocess_request(cr, uid, ids, request, context=None)

class CheckoutInfo:
    mandatory_billing_fields = ["name", "phone", "email", "street", "city", "country_id", "zip"]
    optional_billing_fields = ["company", "state_id"]
    string_billing_fields = ["name", "phone", "email", "street", "city", "zip"]
    mandatory_shipping_fields = ["shipping_name", "shipping_phone", "shipping_street", "shipping_city", "shipping_country_id", "shipping_zip"]
    string_shipping_fields = ["shipping_name", "shipping_phone", "shipping_street", "shipping_city", "shipping_zip"]
    optional_shipping_field = ["shipping_state_id"]

    def mandatory_fields(self):
        return self.mandatory_billing_fields + self.mandatory_shipping_fields

    def optional_fields(self):
        return self.optional_billing_fields + self.optional_shipping_field

    def all_fields(self):
        return self.mandatory_fields() + self.optional_fields()

    def empty(self):
        return dict((field_name, '') for field_name in self.all_fields())

    def from_partner(self, partner):
        result = dict((field_name, getattr(partner, field_name)) for field_name in self.string_billing_fields if getattr(partner, field_name))
        result['state_id'] = partner.state_id and partner.state_id.id or ''
        result['country_id'] = partner.country_id and partner.country_id.id or ''
        result['company'] = partner.parent_id and partner.parent_id.name or ''
        return result

    def from_post(self, post):
        return dict((field_name, post[field_name]) for field_name in self.all_fields() if post[field_name])

class Ecommerce(http.Controller):

    _order = 'website_sequence desc, website_published desc'

    def get_attribute_ids(self):
        attributes_obj = request.registry.get('product.attribute')
        attributes_ids = attributes_obj.search(request.cr, request.uid, [(1, "=", 1)], context=request.context)
        return attributes_obj.browse(request.cr, request.uid, attributes_ids, context=request.context)

    def get_categories(self):
        domain = [('parent_id', '=', False)]

        category_obj = request.registry.get('product.public.category')
        category_ids = category_obj.search(request.cr, SUPERUSER_ID, domain, context=request.context)
        categories = category_obj.browse(request.cr, SUPERUSER_ID, category_ids, context=request.context)

        product_obj = request.registry.get('product.product')
        groups = product_obj.read_group(request.cr, SUPERUSER_ID, [("sale_ok", "=", True), ('website_published', '=', True)], ['public_categ_id'], 'public_categ_id', context=request.context)
        full_category_ids = [group['public_categ_id'][0] for group in groups if group['public_categ_id']]

        for cat_id in category_obj.browse(request.cr, SUPERUSER_ID, full_category_ids, context=request.context):
            while cat_id.parent_id:
                cat_id = cat_id.parent_id
                full_category_ids.append(cat_id.id)
        full_category_ids.append(1)

        return (categories, full_category_ids)

    def get_bin_packing_products(self, product_ids, fill_hole, col_number=4):
        """
        Packing all products of the search into a table of #col_number columns in function of the product sizes
        The website_size_x, website_size_y is use for fill table (default 1x1)
        The website_style_ids datas are concatenate in a html class

        @values:

        product_ids: list of product template
        fill_hole: list of extra product template use to fill the holes
        col_number: number of columns

        @return:

        table (list of list of #col_number items)
        items: {
            'product': browse of product template,
            'x': size x,
            'y': size y,
            'class': html class
        }
        """
        product_obj = request.registry.get('product.template')
        style_obj = request.registry.get('website.product.style')
        request.context['pricelist'] = self.get_pricelist()

        # search for checking of access rules and keep order
        product_ids = product_obj.search(request.cr, request.uid, [("id", 'in', product_ids)], context=request.context)

        size_ids = {}
        style_ids = style_obj.search(request.cr, SUPERUSER_ID, [('html_class', 'like', 'size_%')], context=request.context)
        for style in style_obj.browse(request.cr, SUPERUSER_ID, style_ids, context=request.context):
            size_ids[style.id] = [int(style.html_class[-3]), int(style.html_class[-1])]

        product_list = []
        bin_packing = {}
        bin_packing[0] = {}

        for product in product_obj.browse(request.cr, SUPERUSER_ID, product_ids, context=request.context):
            index = len(product_list)

            # get size and all html classes
            x = product.website_size_x or 1
            y = product.website_size_y or 1
            html_class = " ".join([str(style_id.html_class) for style_id in product.website_style_ids])

            product_list.append({'product': product, 'x': x, 'y': y, 'class': html_class })

            # bin packing products
            insert = False
            line = 0
            while not insert:
                # if not full column get next line
                if len(bin_packing.setdefault(line, {})) >= col_number:
                    line += 1
                    continue

                col = 0
                while col < col_number:
                    if bin_packing[line].get(col, None) != None:
                        col += 1
                        continue

                    insert = True

                    # check if the box can be inserted
                    copy_line = line
                    copy_y = y
                    while copy_y > 0:
                        copy_col = col
                        copy_x = x
                        while copy_x > 0:
                            if copy_col >= col_number or bin_packing.setdefault(copy_line, {}).get(copy_col, None) != None:
                                insert = False
                                break
                            copy_col += 1
                            copy_x -= 1
                        if not insert:
                            break
                        copy_line += 1
                        copy_y -= 1

                    if not insert:
                        col += 1
                        continue

                    # insert the box
                    copy_y = y
                    while copy_y > 0:
                        copy_y -= 1
                        copy_x = x
                        while copy_x > 0:
                            copy_x -= 1
                            bin_packing[line + copy_y][col + copy_x] = False
                    bin_packing[line + copy_y][col + copy_x] = product_list[index]
                    break

                if not insert:
                    line += 1
                else:
                    break

        length = len(bin_packing)

        # browse product to fill the holes
        if fill_hole:
            fill_hole_products = []
            # search for checking of access rules and keep order
            fill_hole = [id for id in fill_hole if id in product_obj.search(request.cr, request.uid, [("id", 'in', fill_hole)], context=request.context)]
            for product in product_obj.browse(request.cr, request.uid, fill_hole, context=request.context):
                fill_hole_products.append(product)
            fill_hole_products.reverse()

        # packaging in list (from dict)
        bin_packing_list = []
        line = 0
        while line < length:
            bin_packing_list.append([])
            col = 0
            while col < col_number:
                if fill_hole and fill_hole_products and bin_packing[line].get(col) == None:
                    bin_packing[line][col] = {'product': fill_hole_products.pop(), 'x': 1, 'y': 1, 'class': "" }
                bin_packing_list[line].append(bin_packing[line].get(col))
                col += 1
            line += 1

        return bin_packing_list

    def get_products(self, product_ids):
        product_obj = request.registry.get('product.template')
        request.context['pricelist'] = self.get_pricelist()
        # search for checking of access rules and keep order
        product_ids = [id for id in product_ids if id in product_obj.search(request.cr, request.uid, [("id", 'in', product_ids)], context=request.context)]
        return product_obj.browse(request.cr, request.uid, product_ids, context=request.context)

    def has_search_filter(self, attribute_id, value_id=None):
        if request.httprequest.args.get('filter'):
            filter = simplejson.loads(request.httprequest.args['filter'])
        else:
            filter = []
        for key_val in filter:
            if key_val[0] == attribute_id and (not value_id or value_id in key_val[1:]):
                return key_val
        return False

    @website.route(['/shop/filter/'], type='http', auth="public", multilang=True)
    def filter(self, add_filter="", **post):
        index = []
        filter = []
        if add_filter:
            filter = simplejson.loads(add_filter)
            for filt in filter:
                index.append(filt[0])
        for key, val in post.items():
            cat = key.split("-")
            if len(cat) < 3 or cat[2] in ('max','minmem','maxmem'):
                continue
            cat_id = int(cat[1])
            if cat[2] == 'min':
                minmem = float(post.pop("att-%s-minmem" % cat[1]))
                maxmem = float(post.pop("att-%s-maxmem" % cat[1]))
                _max = int(post.pop("att-%s-max" % cat[1]))
                _min = int(val)
                if (minmem != _min or maxmem != _max) and cat_id not in index:
                    filter.append([cat_id , [_min, _max] ])
                    index.append(cat_id)
            elif cat_id not in index:
                filter.append([ cat_id, int(cat[2]) ])
                index.append(cat_id)
            else:
                cat[2] = int(cat[2])
                if cat[2] not in filter[index.index(cat_id)][1:]:
                    filter[index.index(cat_id)].append( cat[2] )
            post.pop(key)

        return request.redirect("/shop/?filter=%s%s%s%s" % (
                simplejson.dumps(filter),
                add_filter and "&add_filter=%s" % add_filter or "",
                post.get("search") and "&search=%s" % post.get("search") or "",
                post.get("category") and "&category=%s" % post.get("category") or ""
            ))

    def attributes_to_ids(self, attributes):
        obj = request.registry.get('product.attribute.product')
        domain = [(1, '=', 1)]
        for key_val in attributes:
            domain += [("attribute_id", "=", key_val[0])]
            if isinstance(key_val[1], list):
                domain += [("value", ">=", key_val[1][0]), ("value", "<=", key_val[1][1])]
            else:
                domain += [("value_id", "in", key_val[1:])]
        att_ids = obj.search(request.cr, request.uid, domain, context=request.context)
        att = obj.read(request.cr, request.uid, att_ids, ["product_id"], context=request.context)
        return [r["product_id"][0] for r in att]

    @website.route(['/shop/', '/shop/page/<int:page>/'], type='http', auth="public", multilang=True)
    def category(self, category=0, filter="", page=0, **post):
        # TDE-NOTE: shouldn't we do somethign about product_template without variants ???
        # TDE-NOTE: is there a reason to call a method category when the route is
        # basically a shop without category_id speceified ?

        if 'promo' in post:
            self.change_pricelist(post.get('promo'))
        product_obj = request.registry.get('product.template')

        domain = [("sale_ok", "=", True)]

        # remove product_product_consultant from ecommerce editable mode, this product never be publish
        ref = request.registry.get('ir.model.data').get_object_reference(request.cr, SUPERUSER_ID, 'product', 'product_product_consultant')
        domain += [("id", "!=", ref[1])]

        if post.get("search"):
            domain += ['|', '|', '|',
                ('name', 'ilike', "%%%s%%" % post.get("search")),
                ('description', 'ilike', "%%%s%%" % post.get("search")),
                ('website_description', 'ilike', "%%%s%%" % post.get("search")),
                ('product_variant_ids.public_categ_id.name', 'ilike', "%%%s%%" % post.get("search"))]

        if category:
            cat_id = int(category)
            domain = [('product_variant_ids.public_categ_id.id', 'child_of', cat_id)] + domain

        if filter:
            filter = simplejson.loads(filter)
            if filter:
                ids = self.attributes_to_ids(filter)
                domain = [('id', 'in', ids or [0] )] + domain

        step = 20
        product_count = len(product_obj.search(request.cr, request.uid, domain, context=request.context))
        pager = request.website.pager(url="/shop/", total=product_count, page=page, step=step, scope=7, url_args=post)

        request.context['pricelist'] = self.get_pricelist()

        product_ids = product_obj.search(request.cr, request.uid, domain, limit=step, offset=pager['offset'], order=self._order, context=request.context)
        fill_hole = product_obj.search(request.cr, request.uid, domain, limit=step, offset=pager['offset']+step, order=self._order, context=request.context)

        styles = []
        if not request.context['is_public_user']:
            style_obj = request.registry.get('website.product.style')
            style_ids = style_obj.search(request.cr, request.uid, [(1, '=', 1)], context=request.context)
            styles = style_obj.browse(request.cr, request.uid, style_ids, context=request.context)

        try:
            product_obj.check_access_rights(request.cr, request.uid, 'write')
            has_access_write = True
        except:
            has_access_write = False

        values = {
            'has_access_write': has_access_write,
            'Ecommerce': self,
            'product_ids': product_ids,
            'product_ids_for_holes': fill_hole,
            'search': {
                'search': post.get('search') or '',
                'category': category,
                'filter': filter or '',
            },
            'pager': pager,
            'styles': styles,
            'style_in_product': lambda style, product: style.id in [s.id for s in product.website_style_ids],
        }
        return request.website.render("website_sale.products", values)

    @website.route(['/shop/product/<model("product.template"):product>/'], type='http', auth="public", multilang=True)
    def product(self, product, search='', category='', filter='', promo=None, **kwargs):

        if promo:
            self.change_pricelist(promo)

        category_obj = request.registry.get('product.public.category')

        category_ids = category_obj.search(request.cr, request.uid, [], context=request.context)
        category_list = category_obj.name_get(request.cr, request.uid, category_ids, context=request.context)
        category_list = sorted(category_list, key=lambda category: category[1])

        if category:
            category = category_obj.browse(request.cr, request.uid, int(category), context=request.context)

        request.context['pricelist'] = self.get_pricelist()

        try:
            request.registry.get('product.template').check_access_rights(request.cr, request.uid, 'write')
            has_access_write = True
        except:
            has_access_write = False

        values = {
            'has_access_write': has_access_write,
            'Ecommerce': self,
            'category': category,
            'category_list': category_list,
            'main_object': product,
            'product': product,
            'search': {
                'search': search,
                'category': category and str(category.id),
                'filter': filter,
            }
        }
        return request.website.render("website_sale.product", values)

    @website.route(['/shop/add_product/', '/shop/category/<int:cat_id>/add_product/'], type='http', auth="user", multilang=True, methods=['POST'])
    def add_product(self, cat_id=0, **post):
        Product = request.registry.get('product.product')
        product_id = Product.create(request.cr, request.uid, {
            'name': 'New Product', 'public_categ_id': cat_id
        }, context=request.context)
        product = Product.browse(request.cr, request.uid, product_id, context=request.context)

        return request.redirect("/shop/product/%s/?enable_editor=1" % product.product_tmpl_id.id)

    def get_pricelist(self):
        if not request.httprequest.session.get('ecommerce_pricelist'):
            self.change_pricelist(None)
        return request.httprequest.session.get('ecommerce_pricelist')

    def change_pricelist(self, code):
        request.httprequest.session.setdefault('ecommerce_pricelist', False)

        pricelist_id = False
        if code:
            pricelist_obj = request.registry.get('product.pricelist')
            pricelist_ids = pricelist_obj.search(request.cr, SUPERUSER_ID, [('code', '=', code)], context=request.context)
            if pricelist_ids:
                pricelist_id = pricelist_ids[0]

        if not pricelist_id:
            partner_id = request.registry.get('res.users').browse(request.cr, SUPERUSER_ID, request.uid, request.context).partner_id.id
            pricelist_id = request.registry['sale.order'].onchange_partner_id(request.cr, SUPERUSER_ID, [], partner_id, context=request.context)['value']['pricelist_id']

        request.httprequest.session['ecommerce_pricelist'] = pricelist_id

        order = get_current_order()
        if order:
            values = {'pricelist_id': pricelist_id}
            values.update(order.onchange_pricelist_id(pricelist_id, None)['value'])
            order.write(values)
            for line in order.order_line:
                self.add_product_to_cart(order_line_id=line.id, number=0)

    def add_product_to_cart(self, product_id=0, order_line_id=0, number=1, set_number=-1):
        order_line_obj = request.registry.get('sale.order.line')
        order_obj = request.registry.get('sale.order')

        order = get_current_order()
        if not order:
            order = get_order()

        request.context = dict(request.context, pricelist=self.get_pricelist())

        quantity = 0

        # values initialisation
        values = {}

        domain = [('order_id', '=', order.id)]
        if order_line_id:
            domain += [('id', '=', order_line_id)]
        else:
            domain += [('product_id', '=', product_id)]

        order_line_ids = order_line_obj.search(request.cr, SUPERUSER_ID, domain, context=request.context)
        if order_line_ids:
            order_line = order_line_obj.read(request.cr, SUPERUSER_ID, order_line_ids, [], context=request.context)[0]
            if not product_id:
                product_id = order_line['product_id'][0]
            if set_number >= 0:
                quantity = set_number
            else:
                quantity = order_line['product_uom_qty'] + number
            if quantity < 0:
                quantity = 0
        else:
            fields = [k for k, v in order_line_obj._columns.items()]
            values = order_line_obj.default_get(request.cr, SUPERUSER_ID, fields, context=request.context)
            quantity = 1

        # change and record value
        vals = order_line_obj._recalculate_product_values(request.cr, request.uid, order_line_ids, product_id, context=request.context)
        values.update(vals)

        values['product_uom_qty'] = quantity
        values['product_id'] = product_id
        values['order_id'] = order.id

        if order_line_ids:
            order_line_obj.write(request.cr, SUPERUSER_ID, order_line_ids, values, context=request.context)
            if not quantity:
                order_line_obj.unlink(request.cr, SUPERUSER_ID, order_line_ids, context=request.context)
        else:
            order_line_id = order_line_obj.create(request.cr, SUPERUSER_ID, values, context=request.context)
            order_obj.write(request.cr, SUPERUSER_ID, [order.id], {'order_line': [(4, order_line_id)]}, context=request.context)
        return quantity

    @website.route(['/shop/mycart/'], type='http', auth="public", multilang=True)
    def mycart(self, **post):
        order = get_current_order()
        prod_obj = request.registry.get('product.product')

        if 'promo' in post:
            self.change_pricelist(post.get('promo'))

        suggested_ids = []
        product_ids = []
        if order:
            for line in order.order_line:
                suggested_ids += [p.id for p in line.product_id and line.product_id.suggested_product_ids or []]
                product_ids.append(line.product_id.id)
        suggested_ids = list(set(suggested_ids) - set(product_ids))
        if suggested_ids:
            suggested_ids = prod_obj.search(request.cr, request.uid, [('id', 'in', suggested_ids)], context=request.context)

        # select 3 random products
        suggested_products = []
        while len(suggested_products) < 3 and suggested_ids:
            index = random.randrange(0, len(suggested_ids))
            suggested_products.append(suggested_ids.pop(index))

        values = {
            'int': int,
            'get_categories': self.get_categories,
            'suggested_products': prod_obj.browse(request.cr, request.uid, suggested_products, request.context),
        }
        return request.website.render("website_sale.mycart", values)

    @website.route(['/shop/<path:path>/add_cart/', '/shop/add_cart/'], type='http', auth="public", multilang=True)
    def add_cart(self, path=None, product_id=None, order_line_id=None, remove=None, **kw):
        self.add_product_to_cart(product_id=product_id and int(product_id), order_line_id=order_line_id and int(order_line_id), number=(remove and -1 or 1))
        return request.redirect("/shop/mycart/")

    @website.route(['/shop/add_cart_json/'], type='json', auth="public")
    def add_cart_json(self, product_id=None, order_line_id=None, remove=None):
        quantity = self.add_product_to_cart(product_id=product_id, order_line_id=order_line_id, number=(remove and -1 or 1))
        order = get_current_order()
        return [quantity, order.get_total_quantity(), order.amount_total, request.website.render("website_sale.total", {
                'website_sale_order': order
            }).strip()]

    @website.route(['/shop/set_cart_json/'], type='json', auth="public")
    def set_cart_json(self, path=None, product_id=None, order_line_id=None, set_number=0, json=None):
        return self.add_product_to_cart(product_id=product_id, order_line_id=order_line_id, set_number=set_number)

    @website.route(['/shop/checkout/'], type='http', auth="public", multilang=True)
    def checkout(self, **post):
        cr, uid, context, registry = request.cr, request.uid, request.context, request.registry

        order = get_current_order()

        if not order or order.state != 'draft' or not order.order_line:
            return self.mycart(**post)

        orm_partner = registry.get('res.partner')
        orm_user = registry.get('res.users')
        orm_country = registry.get('res.country')
        country_ids = orm_country.search(cr, SUPERUSER_ID, [(1, "=", 1)], context=context)
        countries = orm_country.browse(cr, SUPERUSER_ID, country_ids, context)
        state_orm = registry.get('res.country.state')
        states_ids = state_orm.search(cr, SUPERUSER_ID, [(1, "=", 1)], context=context)
        states = state_orm.browse(cr, SUPERUSER_ID, states_ids, context)

        info = CheckoutInfo()
        values = {
            'countries': countries,
            'states': states,
            'checkout': info.empty(),
            'shipping': post.get("shipping_different"),
            'error': {},
        }
        checkout = values['checkout']
        error = values['error']

        if not context['is_public_user']:
            partner = orm_user.browse(cr, uid, uid, context).partner_id
            partner_info = info.from_partner(partner)
            checkout.update(partner_info)
            shipping_ids = orm_partner.search(cr, uid, [("parent_id", "=", partner.id), ('type', "=", 'delivery')], context=context)
            if shipping_ids:
                values['shipping'] = "true"
                shipping_partner = orm_partner.browse(cr, uid, shipping_ids[0], context)
                checkout['shipping_name'] = getattr(shipping_partner, 'name')
                checkout['shipping_phone'] = getattr(shipping_partner, 'phone')
                checkout['shipping_street'] = getattr(shipping_partner, 'street')
                checkout['shipping_zip'] = getattr(shipping_partner, 'zip')
                checkout['shipping_city'] = getattr(shipping_partner, 'city')
                checkout['shipping_country_id'] = getattr(shipping_partner, 'country_id')
                checkout['shipping_state_id'] = getattr(shipping_partner, 'state_id')

        for field_name in info.mandatory_fields():
            if not checkout[field_name]:
                error[field_name] = 'missing'

        return request.website.render("website_sale.checkout", values)

    @website.route(['/shop/confirm_order/'], type='http', auth="public", multilang=True)
    def confirm_order(self, **post):
        cr, uid, context, registry = request.cr, request.uid, request.context, request.registry

        order = get_current_order()

        if not order or order.state != 'draft' or not order.order_line:
            return self.mycart(**post)

        orm_parter = registry.get('res.partner')
        orm_user = registry.get('res.users')
        orm_country = registry.get('res.country')
        country_ids = orm_country.search(cr, SUPERUSER_ID, [(1, "=", 1)], context=context)
        countries = orm_country.browse(cr, SUPERUSER_ID, country_ids, context)
        orm_state = registry.get('res.country.state')
        states_ids = orm_state.search(cr, SUPERUSER_ID, [(1, "=", 1)], context=context)
        states = orm_state.browse(cr, SUPERUSER_ID, states_ids, context)

        info = CheckoutInfo()
        values = {
            'countries': countries,
            'states': states,
            'checkout': info.empty(),
            'shipping': post.get("shipping_different"),
            'error': {},
        }
        checkout = values['checkout']
        checkout.update(post)
        error = values['error']

        for field_name in info.mandatory_billing_fields:
            if not checkout[field_name]:
                error[field_name] = 'missing'
        if post.get("shipping_different"):
            for field_name in info.mandatory_shipping_fields:
                if not checkout[field_name]:
                    error[field_name] = 'missing'
        if error:
            return request.website.render("website_sale.checkout", values)

        company_name = checkout['company']
        company_id = None
        if post['company']:
            company_ids = orm_parter.search(cr, SUPERUSER_ID, [("name", "ilike", company_name), ('is_company', '=', True)], context=context)
            company_id = (company_ids and company_ids[0]) or orm_parter.create(cr, SUPERUSER_ID, {'name': company_name, 'is_company': True}, context)

        billing_info = dict(checkout)
        billing_info['parent_id'] = company_id;

        if not context['is_public_user']:
            partner_id = orm_user.browse(cr, uid, uid, context=context).partner_id.id
            orm_parter.write(cr, uid, [partner_id], billing_info, context=context)
        else:
            partner_id = orm_parter.create(cr, SUPERUSER_ID, billing_info, context=context)

        shipping_id = None
        if post.get('shipping_different'):
            shipping_info = {
                'phone': post['shipping_phone'],
                'zip': post['shipping_zip'],
                'street': post['shipping_street'],
                'city': post['shipping_city'],
                'name': post['shipping_name'],
                'type': 'delivery',
                'parent_id': partner_id,
                'country_id': post['shipping_country_id'],
                'state_id': post['shipping_state_id'],
            }
            domain = [(key, '_id' in key and '=' or 'ilike', '_id' in key and value and int(value) or False)
                for key, value in shipping_info.items() if key in info.mandatory_billing_fields + ["type", "parent_id"]]

            shipping_ids = orm_parter.search(cr, SUPERUSER_ID, domain, context=context)
            if shipping_ids:
                shipping_id = shipping_ids[0]
                orm_parter.write(cr, SUPERUSER_ID, [shipping_id], shipping_info, context)
            else:
                shipping_id = orm_parter.create(cr, SUPERUSER_ID, shipping_info, context)

        order_info = {
            'partner_id': partner_id,
            'message_follower_ids': [(4, partner_id)],
            'partner_invoice_id': partner_id,
            'partner_shipping_id': shipping_id or partner_id
        }
        order_info.update(registry.get('sale.order').onchange_partner_id(cr, SUPERUSER_ID, [], order.partner_id.id, context=context)['value'])
        order.write(order_info)

        return request.redirect("/shop/payment/")

    @website.route(['/shop/payment/'], type='http', auth="public", multilang=True)
    def payment(self, **post):
        order = get_current_order()

        if not order or not order.order_line:
            return self.mycart(**post)

        values = {
            'partner': False,
            'order': order
        }

        payment_obj = request.registry.get('portal.payment.acquirer')
        payment_ids = payment_obj.search(request.cr, SUPERUSER_ID, [('visible', '=', True)], context=request.context)
        values['payments'] = payment_obj.browse(request.cr, SUPERUSER_ID, payment_ids, request.context)
        for payment in values['payments']:
            content = payment_obj.render(request.cr, SUPERUSER_ID, payment.id, order, order.name, order.pricelist_id.currency_id, order.amount_total)
            payment._content = content

        return request.website.render("website_sale.payment", values)

    @website.route(['/shop/payment_validate/'], type='http', auth="public", multilang=True)
    def payment_validate(self, **post):
        request.httprequest.session['ecommerce_order_id'] = False
        request.httprequest.session['ecommerce_pricelist'] = False
        return request.redirect("/shop/")

    @website.route(['/shop/change_sequence/'], type='json', auth="public")
    def change_sequence(self, id, top):
        product_obj = request.registry.get('product.template')
        if top:
            product_obj.set_sequence_top(request.cr, request.uid, [id], context=request.context)
        else:
            product_obj.set_sequence_bottom(request.cr, request.uid, [id], context=request.context)

    @website.route(['/shop/change_styles/'], type='json', auth="public")
    def change_styles(self, id, style_id):
        product_obj = request.registry.get('product.template')
        product = product_obj.browse(request.cr, request.uid, id, context=request.context)

        remove = []
        active = False
        for style in product.website_style_ids:
            if style.id == style_id:
                remove.append(style.id)
                active = True
                break

        style = request.registry.get('website.product.style').browse(request.cr, request.uid, style_id, context=request.context)

        if remove:
            product.write({'website_style_ids': [(3, rid) for rid in remove]})
        if not active:
            product.write({'website_style_ids': [(4, style.id)]})

        return not active

    @website.route(['/shop/change_size/'], type='json', auth="public")
    def change_size(self, id, x, y):
        product_obj = request.registry.get('product.template')
        product = product_obj.browse(request.cr, request.uid, id, context=request.context)
        return product.write({'website_size_x': x, 'website_size_y': y})

# vim:expandtab:tabstop=4:softtabstop=4:shiftwidth=4: