#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tornado
import tornado.web
import datetime
import re
import log
import json
import etc
import mongo
import data_user
import urlparse
import util
import admin
import session_base
from session_base import ApiSession
from session_mc import BaseHandler


class SignOutHandler( BaseHandler ) :

    @tornado.web.asynchronous
    def post( self ) :
        try :
            self.clear_all_cookies()
            if self.get_current_user() :
                domain = util.get_domain_from_host( self.request.host )
                data_user.set_logout( mongo.db_pool[domain].user, self.ss_data['uid'] )
                self.ss_store.delete( self.ss_data.ss_id )
        except Exception as e:
            log.exp(e)
        finally :
            self.ss_data = None
            res = { 'op':True, 'msg':'已退出' }
            self.write( json.dumps(res) )
            self.finish()
            return


class SignUpHandler( BaseHandler ) :

    @tornado.web.asynchronous
    def post( self ) :
        try :
            email = self.get_argument( 'email', default=None )
            passwd = self.get_argument( 'passwd', default=None )
            log.i( 'email=%s , passwd=%s'%(email,passwd) )
            if not email :
                log.w( 'empty email' )
                res = { 'op':False, 'msg':'邮箱不能为空' }
                log.i( 'email=%s , passwd=%s'%(email,passwd) )
                self.write( json.dumps(res) )
                self.finish()
                return
            email = email.strip().lower()
            remail = re.compile( etc.mail_regex )
            if not remail.match( email ) :
                log.w( 'email verify failed' )
                res = { 'op':False, 'msg':'邮箱格式有误' }
                self.write( json.dumps(res) )
                self.finish()
                return
            domain = util.get_domain_from_host( self.request.host )
            if data_user.find_user_by_email( mongo.db_pool[domain].user, email ) :
                log.w( 'email has been used' )
                res = { 'op':False, 'msg':'该邮箱已注册' }
                self.write( json.dumps(res) )
                self.finish()
                return
            uid = data_user.count_userid( mongo.db_pool[domain].counter )
            if not uid :
                log.e( 'uid fetching error' )
                res = { 'op':False, 'msg':etc.err_500 }
                self.write( json.dumps(res) )
                self.finish()
                return
            res = data_user.create_user( mongo.db_pool[domain].user, uid, email, passwd )
            if not res :
                log.e( 'user create error' )
                res = { 'op':False, 'msg':etc.err_500 }
                self.write( json.dumps(res) )
                self.finish()
                return
            log.i( 'new id created: uid=%s , email=%s , passwd=%s'%(uid,email,passwd) )
            res = { 'op':True, 'msg':'感谢您注册，现在可以登录了' }
            self.write( json.dumps(res) )
            self.finish()
            return
        except Exception as e :
            log.exp(e)
            res = { 'op':False, 'msg':etc.err_500 }
            self.write( json.dumps(res) )
            self.finish()
            return


class FindPwdHandler( BaseHandler ) :

    @tornado.web.asynchronous
    def post( self ) :
        try :
            email = self.get_argument( 'email', default=None )
            log.i( 'email=%s' % email)
            if not email :
                log.w( 'empty email' )
                res = { 'op':False, 'msg':'邮箱不能为空' }
                log.i( 'email=%s' % email )
                self.write( json.dumps(res) )
                self.finish()
                return
            email = email.strip().lower()
            remail = re.compile( etc.mail_regex )
            if not remail.match( email ) :
                log.w( 'email verify failed' )
                res = { 'op':False, 'msg':'邮箱格式有误' }
                self.write( json.dumps(res) )
                self.finish()
                return
            domain = util.get_domain_from_host( self.request.host )
            if not data_user.find_user_by_email( mongo.db_pool[domain].user, email ) :
                log.w( 'email does not exit' )
                res = { 'op':False, 'msg':'该邮箱还没有注册' }
                self.write( json.dumps(res) )
                self.finish()
                return
            vid = util.make_a_secret()
            vid = vid.replace( "+", "" )
            vid = vid.replace( '=', "" ) #去掉 + = 号避免get请求编码错误
            reset = data_user.create_reset( mongo.db_pool[domain].reset, email, vid )
            if not reset:
                log.e( 'reset_pwd create error')
                res = { 'op': False, 'msg': etc.err_500}
                self.write( json.dumps(res) )
                self.finish();
                return
            log.i( 'new reset_pwd created: vid=%s email=%s' % (str(vid),email) )
            mail = admin.send_mail( email, '重置密码', etc.url['user_resetpwd']+'?vid='+vid )
            if not mail:
                log.w('send mail failure')
                reset = data_user.del_reset( mongo.db_pool[domain].reset, email )
                res = { 'op':True, 'msg':'发送邮件失败，请重新尝试' }
                self.write(json.dumps(res))
                self.finish();
                return
            else:
                log.i('send mail success')
                res = { 'op':True, 'msg':'找回密码已经发送到您的邮箱，请查收' }
                self.write( json.dumps(res) )
                self.finish()
                return
        except Exception as e :
            log.exp(e)
            res = { 'op':False, 'msg':etc.err_500 }
            self.write( json.dumps(res) )
            self.finish()
            return


class ResetPwdHandler( BaseHandler ) :

    @tornado.web.asynchronous
    def post( self ) :
        try :
            email = self.get_argument( 'email',default=None )
            passwd = self.get_argument( 'passwd',default=None )
            log.i('email=%s passwd=%s' % (email, passwd))
            if not email or not passwd:
                log.w( 'empty passwd' )
                res = { 'op':False, 'msg':'密码不能为空' }
                self.write( json.dumps(res) )
                self.finish()
                return
            domain = util.get_domain_from_host( self.request.host )
            user = data_user.update_user_by_email( mongo.db_pool[domain].user, email, passwd )
            if not user :
                log.e( 'user update error' )
                res = { 'op':False, 'msg':etc.err_500 }
                self.write( json.dumps(res) )
                self.finish()
                return
            reset = data_user.del_reset( mongo.db_pool[domain].reset, email )
            log.i(reset)

            res = { 'op': True, 'msg': '重置密码成功'}
            self.write( json.dumps(res) )
            self.finish();
            return
        except Exception as e :
            log.exp(e)
            res = { 'op':False, 'msg':etc.err_500 }
            self.write( json.dumps(res) )
            self.finish()
            return


class EmailEditHandler( BaseHandler ):

    @ApiSession
    def post( self ) :
        try :
            new_email = self.get_argument( 'new_email', default=None )
            log.i( 'email=%s' % new_email)
            if not new_email :
                log.w( 'empty email' )
                res = { 'op':False, 'msg':'邮箱不能为空' }
                log.i( 'email=%s' % new_email )
                self.write( json.dumps(res) )
                self.finish()
                return
            email = new_email.strip().lower()
            remail = re.compile( etc.mail_regex )
            if not remail.match( email ) :
                log.w( 'email verify failed' )
                res = { 'op':False, 'msg':'邮箱格式有误' }
                self.write( json.dumps(res) )
                self.finish()
                return
            domain = util.get_domain_from_host( self.request.host )
            uid = self.ss_data['uid']
            res = data_user.update_user_by_id( mongo.db_pool[domain].user, uid, None, email, None )
            if not res:
                log.e( 'update email by uid error')
                res = { 'op': False, 'msg': etc.err_500}
                self.write( json.dumps(res) )
                self.finish();
                return
            log.i ('update email by uid success')
            res = {'op':True, 'msg': "修改邮箱成功"}
            self.write( json.dumps(res) )
            self.finish()
            return
        except Exception as e :
            log.exp(e)
            res = { 'op':False, 'msg':etc.err_500 }
            self.write( json.dumps(res) )
            self.finish()
            return


class PwdEditHandler( BaseHandler ) :

    @ApiSession
    def post( self ) :
        try :
            old_pwd = self.get_argument('old_pwd', default=None)
            new_pwd = self.get_argument('new_pwd', default=None)
            log.i( 'old pwd=%s, new pwd = ' % (old_pwd, new_pwd))
            if not new_pwd or not old_pwd:
                log.w( 'empty new_pwd or old_pwd' )
                res = { 'op':False, 'msg':'密码不能为空' }
                log.i( 'old pwd=%s, new pwd = ' % (old_pwd, new_pwd))
                self.write( json.dumps(res) )
                self.finish()
                return
            domain = util.get_domain_from_host( self.request.host )
            uid = self.ss_data['uid']
            res = data_user.update_user_by_id( mongo.db_pool[domain].user, uid, new_pwd, None, None )
            if not res:
                log.e( 'update password by uid error')
                res = { 'op': False, 'msg': etc.err_500}
                self.write( json.dumps(res) )
                self.finish();
                return
            log.i ('update password by uid success')
            res = {'op':True, 'msg': "修改密码成功"}
            self.write( json.dumps(res) )
            self.finish()
            return
        except Exception as e :
            log.exp(e)
            res = { 'op':False, 'msg':etc.err_500 }
            self.write( json.dumps(res) )
            self.finish()
            return


class ApiNotFoundHandler( BaseHandler ) :

    def get( self ) :
        raise tornado.web.HTTPError( 503 )

    @tornado.web.asynchronous
    def post( self ) :
        log.i( '503' )
        res = { 'op':False, 'msg':'无此功能' }
        self.write( json.dumps(res) )
        self.finish()