package front

import (
	"fmt"
	"jfw/config"
	"jfw/filter"
	"jfw/jyutil"
	"jfw/qrmanager"
	"jfw/tools"
	"jfw/wx"
	"log"
	//"math/rand"
	"qfw/util"
	"qfw/util/elastic"
	"qfw/util/redis"
	"strings"
	"sync"
	"time"

	"github.com/go-xweb/httpsession"
	"golang.org/x/net/websocket"

	"github.com/go-xweb/xweb"
	"gopkg.in/mgo.v2/bson"
)

type userPool struct {
	lock    sync.Mutex
	openIds []string
	user    map[string]*map[string]interface{}
}
type Front struct {
	*xweb.Action
	ajaxPolling        xweb.Mapper `xweb:"/front/ajaxPolling"`      //登录轮询
	getLoginNum        xweb.Mapper `xweb:"/front/getLoginNum/(.*)"` //
	login              xweb.Mapper `xweb:"/front/login/(.*)"`       //登录
	hasSign            xweb.Mapper `xweb:"/front/hasSign"`          //是否登录
	signOut            xweb.Mapper `xweb:"/front/signOut"`          //注销
	sess               xweb.Mapper `xweb:"/front/sess/(.*)"`        //微信跳转session登录
	viewdemo           xweb.Mapper `xweb:"/front/viewdemo"`         //微信跳转session登录
	getpage            xweb.Mapper `xweb:"/swordfish/getpage"`
	wxsearch           xweb.Mapper `xweb:"/swordfish/search"`             //剑鱼微信查询
	wxsearchlist       xweb.Mapper `xweb:"/swordfish/searchlist"`         //剑鱼微信查询结果展示
	wxsearchlistPaging xweb.Mapper `xweb:"/swordfish/searchlist/paging"`  //剑鱼微信查询结果展示--分页
	delWxHistorySearch xweb.Mapper `xweb:"/swordfish/delWxHistorySearch"` //剑鱼微信删除历史搜索
	visitRedirect      xweb.Mapper `xweb:"/visit/redirect"`               //剑鱼跳转访问请求，后续统计
	//iknow           xweb.Mapper `xweb:"/visit/iknow"`          //剑鱼跳转访问请求，后续统计
	ajaxReq          xweb.Mapper `xweb:"/member/swordfish/ajaxReq"`
	wxpushView       xweb.Mapper `xweb:"/wxpush/wxpushview"`        //推送结果预览
	wxpushViewPaging xweb.Mapper `xweb:"/wxpush/wxpushview/paging"` //推送结果预览--分页
	guide            xweb.Mapper `xweb:"/swordfish/guide/(.*)"`
	share            xweb.Mapper `xweb:"/swordfish/share/([^.]*)"`
	wxprotocol       xweb.Mapper `xweb:"/swordfish/wxprotocol"` //微信剑鱼协议
	delc             xweb.Mapper `xweb:"/delcache/(.+)"`        //删除模板缓存
	wxpushListInfo   xweb.Mapper `xweb:"/wxpush/bidinfo/(.*)"`  //推送列表
	feedback         xweb.Mapper `xweb:"/swordfish/feedback"`   //意见反馈
	wxpushAjaxReq    xweb.Mapper `xweb:"/wxpush/bid/ajaxReq"`
	newSordfish      xweb.Mapper `xweb:"/"`                                  //剑鱼pc首页
	searchinfolist   xweb.Mapper `xweb:"/swordfish/searchinfolist(.*).html"` //剑鱼pc查询
	about            xweb.Mapper `xweb:"/swordfish/about"`
	shareabout       xweb.Mapper `xweb:"/swordfish/shareabout/([^.]*)"`
	getIndexData     xweb.Mapper `xweb:"/front/index.*"`
	urlrecord        xweb.Mapper `xweb:"/front/urlrecord.*"`
	isrecord         xweb.Mapper `xweb:"/front/isrecord/(.*)"`
	praise           xweb.Mapper `xweb:"/swordfish/praise"`
	getpraise        xweb.Mapper `xweb:"/swordfish/getpraise"`
	aboutsearch      xweb.Mapper `xweb:"/swordfish/aboutsearch"`
	aboutSR          xweb.Mapper `xweb:"/swordfish/aboutsearchresult"`
	delOL            xweb.Mapper `xweb:"/swordfish/delovertimelist"` //手动删除30天无更新数据
	pcAjaxReq        xweb.Mapper `xweb:"/front/pcAjaxReq"`
	//pcVisitRedirect  xweb.Mapper `xweb:"/pcdetail/(.*).html"` //pc剑鱼跳转访问请求，后续统计
	//aiknow          xweb.Mapper `xweb:"/about/iknow"`
	myFeedbacks    xweb.Mapper `xweb:"/swordfish/myFeedbacks"`
	wxkeywords     xweb.Mapper `xweb:"/swordfish/wxkeywords"`
	wxscope        xweb.Mapper `xweb:"/swordfish/wxscope"`
	wxerr          xweb.Mapper `xweb:"/mob/err"`
	getRecomKWs    xweb.Mapper `xweb:"/member/getRecomKWs"`          //获取推荐关键词
	behaviorRecord xweb.Mapper `xweb:"/member/behaviorRecord"`       //记录用户点击的关键词
	tSGuide        xweb.Mapper `xweb:"/front/tenderSubscribe/guide"` //引导页
	transfer       xweb.Mapper `xweb:"/front/transfer"`              //原文链接中转
	lifirst        xweb.Mapper `xweb:"/front/lifirst"`               //第一次访问
	jyblog         xweb.Mapper `xweb:"/jyblog/index([^.]*).html"`    //剑鱼博客
	jybdetail      xweb.Mapper `xweb:"/jyblog/([^.]*).html"`         //剑鱼博客三级页
	blogpraise     xweb.Mapper `xweb:"/jyblog/blogpraise"`           //剑鱼博客三级页点赞
	searchResult   xweb.Mapper `xweb:"/list/(\\w+)/(\\w+).html"`     //剑鱼分类 地区结果列表
	encrypt        xweb.Mapper `xweb:"/share/encrypt"`               //分享三级页加密
	//	onekey            xweb.Mapper `xweb:"/swordfish/onekey"`             //一键报告
	historypush       xweb.Mapper `xweb:"/swordfish/historypush"`        //历时推送记录
	historypushPaging xweb.Mapper `xweb:"/swordfish/historypush/paging"` //历时推送记录--分页
	aboutus           xweb.Mapper `xweb:"/front/aboutus.html"`           //关于我们
	busicooperation   xweb.Mapper `xweb:"/front/busicooperation.html"`   //商务合作
	//bidsearchforent	  xweb.Mapper `xweb:"/front/bidsearchforent.html"`   //中标企业搜索

	/********************wxkeyset:v1.8**************************/
	wxrssset        xweb.Mapper `xweb:"/swordfish/page"`
	wxKeysetAjaxReq xweb.Mapper `xweb:"/wxkeyset/ajaxReq"`           //订阅词ajax请求
	wxKeyset        xweb.Mapper `xweb:"/wxkeyset/keyset/(\\w+)"`     //订阅词设置
	subscribe       xweb.Mapper `xweb:"/front/subscribe.html"`       //电脑版剑鱼设置
	gethotkey       xweb.Mapper `xweb:"/front/gethotkey"`            //获取热词
	rediskw         xweb.Mapper `xweb:"/front/rediskw"`              //pc订阅词存redis
	notin           xweb.Mapper `xweb:"/notin/page"`                 //未登录用户访问三级页中转页
	topics          xweb.Mapper `xweb:"/promotional/topics.html"`    //SEM推广
	mobtopics       xweb.Mapper `xweb:"/promotional/mobtopics.html"` //移动端专题推广
	saveuserlogs    xweb.Mapper `xweb:"/front/saveuserlogs"`         //保存用户关注日志
	followinfo      xweb.Mapper `xweb:"/front/followinfo"`           //redis用户关注日志

	/********************dev:2.0**************************/
	getClassifyList xweb.Mapper `xweb:"/front/getClassifyList"`  //得到标签页表格数据
	advservices     xweb.Mapper `xweb:"/front/advservices.html"` //广告服务
	extension       xweb.Mapper `xweb:"/extension/(.*).html"`    //推广页面
	//getQR           xweb.Mapper `xweb:"/front/getQR"`            //取二维码
}

var sewx util.SimpleEncrypt //微信的加密方法
var mongodb = tools.MQFW
var urlMap map[string]interface{}

//var userPoolSize = 1000
//var up userPool
var se = util.SE //移到tools中
var payCallBackChan chan bool = make(chan bool, 1)

func init() {
	sewx = util.SimpleEncrypt{Key: "topnet"}
	xweb.AddAction(&Front{})
	xweb.AddAction(&Short{})
	urlMap = config.Sysconfig["redirect"].(map[string]interface{})
	//userPoolSize = util.IntAllDef(config.Sysconfig["userPoolSize"], userPoolSize)
	//up.user = make(map[string]*map[string]interface{})
}

//轮询查登录状态
func (f *Front) AjaxPolling() {
	reqType, _ := f.GetInteger("reqType")
	if reqType == 1 {
		shareIds := f.GetString("shareIds")
		shareidlist := strings.Split(shareIds, "___")
		if shareIds != "" && len(shareidlist) > 1 {
			shareidnum := shareidlist[0]
			shareidkop := shareidlist[1]
			PutWsByCode(se.DecodeString(shareidnum), nil, f.Session())
			PutWsByCode(se.DecodeString(shareidkop), nil, f.Session())
			f.ServeJson(map[string]string{})
		}
	} else if reqType == 2 {
		userInfo, _ := f.GetSession("rpcBackUserInfo").(map[string]interface{})
		f.ServeJson(userInfo)
	} else if reqType == 3 {
		reply := ""
		userId := se.DecodeString(f.GetString("userId"))
		qrToLab_ok, _ := redis.Exists("other", "qrToLab_"+userId)
		if qrToLab_ok {
			redis.Del("other", "qrToLab_"+userId)
			reply = "qrToLab_ok"
		}
		qrToLab_open_ok, _ := redis.Exists("other", "qrToLab_open_"+userId)
		if qrToLab_open_ok {
			redis.Del("other", "qrToLab_open_"+userId)
			reply = "qrToLab_open_ok"
		}
		if qrToLab_ok && qrToLab_open_ok {
			reply = "qrToLab_ok_open_ok"
		}
		f.ServeJson(map[string]string{"result": reply})
	}
}

//广告服务
func (f *Front) Advservices() error {
	var shareid = f.GetString("id")
	if len(shareid) == 0 {
		shareid = "10" //fmt.Sprintf("%s%d", config.Seoconfig["jyggfwy"].(string)+fmt.Sprintf("%d", time.Now().UnixNano())[7:14], rand.Intn(9))
	}
	f.T["logid"] = config.Seoconfig["jyggfwy"].(string)
	f.T["shareid"] = se.EncodeString(shareid)
	return f.Render("/pc/advservices.html", &f.T)
}

//移动端专题推广
func (f *Front) Mobtopics() error {
	return f.Render("/active/mobtopics.html")
}

//移动端专题推广
func (f *Front) Extension(page string) error {
	//今日头条和百度推广用的同一个页面，如以后有变动，需拆分成两个。
	if page != "tengxun" {
		page = "baidu"
	}
	return f.Render("/active/ext-" + page + ".html")
}

//SEM推广
func (f *Front) Topics() error {
	var shareid = f.GetString("id")
	if len(shareid) == 0 {
		shareid = "10" //fmt.Sprintf("%s%d", config.Seoconfig["jySEMtgy"].(string)+fmt.Sprintf("%d", time.Now().UnixNano())[7:14], rand.Intn(9))
	}
	f.T["logid"] = config.Seoconfig["jySEMtgy"].(string)
	f.T["shareid"] = se.EncodeString(shareid)
	f.DisableHttpCache()
	lastBids := elastic.GetPage("bidding", "bidding", "{}", `{"publishtime":-1}`, `"_id","title","publishtime","toptype","subtype","type","area","href"`, 0, 18)
	if lastBids != nil && len(*lastBids) > 0 {
		lbnHtml, olHtml := structureLastBidsHtml(lastBids)
		f.T["lbnHtml"] = lbnHtml
		f.T["olHtml"] = olHtml
	}

	return f.Render("/active/topics.html", &f.T)
}

//
func (f *Front) Notin() error {
	ref := f.GetSession("referer")
	if ref != nil && ref != "" {
		f.T["ref"] = ref.(string)
	}
	var shareid = f.GetString("id")
	if len(shareid) == 0 {
		shareid = "10" //fmt.Sprintf("%s%d", config.Seoconfig["jysskzy"].(string)+fmt.Sprintf("%d", time.Now().UnixNano())[7:14], rand.Intn(9))
	}
	f.T["logid"] = config.Seoconfig["jysskzy"].(string)
	f.T["shareid"] = se.EncodeString(shareid)
	return f.Render("/pc/notin.html", &f.T)
}

//原实验室socket
func QrToLab(ws *websocket.Conn) {
	var receive, userId string
	var qrToLab_ok, qrToLab_open_ok bool
	//接收消息
	go func() {
		for {
			err := websocket.Message.Receive(ws, &receive)
			if err != nil {
				receive = "close"
				//log.Println("websocket接收失败！", err)
				return
			}
			if receive == "close" {
				return
			} else if receive != "close" { //接收到userid
				userId = se.DecodeString(receive)
			}
		}
	}()
	//发送消息
	for {
		time.Sleep(2 * time.Second)
		if receive == "close" { //接收到关闭信息
			ws.Close()
			return
		} else if userId == "" {
			continue
		}
		var reply string
		//是否进入实验室
		if !qrToLab_ok {
			qrToLab_ok, _ = redis.Exists("other", "qrToLab_"+userId)
			if qrToLab_ok {
				reply = "qrToLab_ok"
			}
		}
		//是否打开开关
		if !qrToLab_open_ok {
			qrToLab_open_ok, _ = redis.Exists("other", "qrToLab_open_"+userId)
			if qrToLab_open_ok {
				reply = "qrToLab_open_ok"
			}
		}
		if reply == "" {
			continue
		}
		if err := websocket.Message.Send(ws, reply); err != nil {
			redis.Del("other", "qrToLab_"+userId)
			redis.Del("other", "qrToLab_open_"+userId)
			//log.Println("websocket发送失败！", err)
			ws.Close()
			return
		}
		if reply == "qrToLab_ok" {
			redis.Del("other", "qrToLab_"+userId)
		} else if reply == "qrToLab_open_ok" {
			redis.Del("other", "qrToLab_open_"+userId)
		}
		if qrToLab_ok && qrToLab_open_ok {
			ws.Close()
			return
		}
	}
}

//原登录关注socket
func ServeWs(ws *websocket.Conn) {
	var err error
	var shareid = ""
	var openid = ""
	var allShareid string
	//接收消息
	go func() {
		for {
			if err = websocket.Message.Receive(ws, &allShareid); err != nil {
				log.Println("websocket接受失败或结束！")
				allShareid = "error"
				ws.Close()
				return
			}
			if allShareid == "" {
				continue
			}
		}
	}()
	for {
		if allShareid == "" {
			continue
		}
		if allShareid == "error" {
			return
		}
		shareidlist := strings.Split(allShareid, "___")
		if allShareid != "" && len(shareidlist) > 1 {
			shareidnum := strings.Split(allShareid, "___")[0]
			shareidkop := strings.Split(allShareid, "___")[1]
			//log.Println(se.DecodeString(shareidnum) + "----" + se.DecodeString(shareidkop))
			shareid = shareidnum
			openid = redis.GetStr("sso", "p_usershare_"+se.DecodeString(shareidnum))
			if openid == "" {
				openid = redis.GetStr("sso", "p_usershare_"+se.DecodeString(shareidkop))
				shareid = shareidkop
			}
			if openid == "" {
				shareid = ""
			}
		}
		if shareid == "" {
			continue
		}
		//log.Println("22222shareid:", shareid)
		if err = websocket.Message.Send(ws, shareid); err != nil {
			log.Println("websocket发送失败或结束！")
			ws.Close()
			return
		}
		if shareid != "" {
			ws.Close()
			return
		}
	}
}

//
func (f *Front) Followinfo() error {
	var pid = f.GetString("pid")
	var kid = f.GetString("kid")
	var oid = f.GetString("oid")
	oldData := redis.Get("sso", "p_userdata_"+se.DecodeString(oid))
	var Rurl = util.ObjToString(f.GetSession("RURL"))
	var Rref = f.GetString("rref")
	rheader := f.Request.Header
	rhdua := "" //UA
	if len(rheader["User-Agent"]) > 0 {
		rhdua = rheader["User-Agent"][0]
	}
	userData := make(map[string]interface{})
	userData["Ros"] = filter.GetOS(rhdua)
	userData["Rip"] = filter.GetIp(f.Request)
	userData["Rbrowse"] = filter.GetBrowse(rhdua)
	if f.GetSession("RReferer") == nil || util.ObjToString(f.GetSession("RReferer")) == "" {
		if Rref == "" {
			f.SetSession("RReferer", Rurl)
		} else {
			f.SetSession("RReferer", Rref)
		}
	}
	userData["RURL"] = Rurl
	modulelist := config.Seoconfig["module"].(map[string]interface{})
	for k, v := range modulelist {
		if strings.Contains(Rurl, k) {
			f.SetSession("RModule", v)
		}
	}
	if f.GetSession("RModule") == nil || util.ObjToString(f.GetSession("RModule")) == "" {
		f.SetSession("RModule", "首页")
	}
	//活动页模块
	if len(Rurl) > 1 && strings.Contains(Rurl, "id=") {
		activeCode := strings.Split(Rurl, "id=")[1]
		//首先查看是否从百度等搜索引擎过来的referer
		sourcelist := config.Seoconfig["source"].(map[string]interface{})
		for k, v := range sourcelist {
			if strings.Contains(activeCode, k) {
				if f.GetSession("RSource") == nil {
					f.SetSession("RSource", v)
					f.SetSession("RModule", activeCode+"活动页")
					f.SetSession("RActiveCode", activeCode)
				}
			}
		}
	}
	userData["RModule"] = f.GetSession("RModule")
	userData["RActiveCode"] = f.GetSession("RActiveCode")
	userData["RReferer"] = f.GetSession("RReferer")
	if f.GetSession("RSource") == nil || util.ObjToString(f.GetSession("RSource")) == "" {
		//首先查看是否从百度等搜索引擎过来的referer
		refererlist := config.Seoconfig["referer"].(map[string]interface{})
		for k, v := range refererlist {
			if strings.Contains(Rref, k) {
				if f.GetSession("RSource") == nil {
					f.SetSession("RSource", v)
				}
			}
		}
		if f.GetSession("RSource") == nil || util.ObjToString(f.GetSession("RSource")) == "" {
			f.SetSession("RSource", "剑鱼网站")
		}
	}
	userData["RSource"] = f.GetSession("RSource")
	userData["Rparamkey"] = f.GetSession("paramkey")
	userData["Rparampublishtime"] = f.GetSession("parampublishtime")
	userData["Rparamarea"] = f.GetSession("paramarea")
	userData["Rparaminfotype"] = f.GetSession("paraminfotype")
	userData["Rprojectname"] = f.GetSession("projectname")
	if oldData != nil {
		redis.Put("sso", "p_userdata_"+se.DecodeString(pid), oldData, 13*60)
		redis.Put("sso", "p_userdata_"+se.DecodeString(kid), oldData, 13*60)
	} else {
		redis.Put("sso", "p_userdata_"+se.DecodeString(pid), userData, 13*60)
		redis.Put("sso", "p_userdata_"+se.DecodeString(kid), userData, 13*60)
	}
	f.ServeJson(map[string]string{
		"result": "ok",
	})
	return nil
}

//
func (f *Front) Saveuserlogs() error {
	defer util.Catch()
	shareid := f.GetString("shareid")
	openid := redis.GetStr("sso", "p_userlogs_"+se.DecodeString(shareid))
	//forid := ""
	//if shareid != "" {
	//	forid = se.DecodeString(shareid)[:2]
	//}
	s_paramkey := ""
	s_parampublishtime := ""
	s_paramarea := ""
	s_paraminfotype := ""
	s_paramprojectname := ""
	s_paramkey = util.ObjToString(f.GetSession("paramkey"))
	s_parampublishtime = util.ObjToString(f.GetSession("parampublishtime"))
	s_paramarea = util.ObjToString(f.GetSession("paramarea"))
	s_paraminfotype = util.ObjToString(f.GetSession("paraminfotype"))
	s_paramprojectname = util.ObjToString(f.GetSession("projectname"))
	logdata := &UserLog{}
	//log.Println("保存新用户日志：", openid)
	if len(openid) > 0 && openid != "" {
		logdata.s_openid = openid
		logdata.s_shareid = se.DecodeString(shareid)
		logdata.s_nickname = util.ObjToString(f.GetSession("nickname"))
		logdata.s_url = util.ObjToString(f.GetSession("RURL"))
		logdata.s_model = util.ObjToString(f.GetSession("RModule"))
		logdata.s_activecode = util.ObjToString(f.GetSession("RActiveCode"))
		logdata.s_referrer = util.ObjToString(f.GetSession("RReferer"))
		logdata.s_usersource = util.ObjToString(f.GetSession("RSource"))
		logdata.i_action = 1
		logdata.s_paramkey = s_paramkey
		logdata.s_parampublishtime = s_parampublishtime
		logdata.s_paramarea = s_paramarea
		logdata.s_paraminfotype = s_paraminfotype
		logdata.s_paramprojectname = s_paramprojectname
		logdata.s_os = util.ObjToString(f.GetSession("Ros"))
		logdata.s_ip = util.ObjToString(f.GetSession("Rip"))
		logdata.s_browse = util.ObjToString(f.GetSession("Rbrowse"))
		//SaveUserLogs(logdata)
	}
	f.ServeJson(map[string]string{
		"result": "ok",
	})
	return nil
}

//
func (f *Front) Login(key string) error {
	shareid := se.DecodeString(key)
	openid := redis.GetStr("sso", "p_usershare_"+shareid)
	if openid != "" {
		f.SetSession("openid", openid)
		redisheadimg := redis.Get("other", "newUser-"+openid)
		if redisheadimg == nil {
			redisheadimg = ""
		}
		user, _ := mongodb.FindOneByField("user", `{"s_m_openid":"`+openid+`"}`, `{"s_nickname":1,"s_headimage":1,"s_m_openid":1}`)
		if user != nil && len(*user) > 0 {
			f.ServeJson(map[string]string{
				"result":       "ok",
				"s_nickname":   fmt.Sprint((*user)["s_nickname"]),
				"s_headimage":  fmt.Sprint((*user)["s_headimage"]),
				"redisheadimg": fmt.Sprint(redisheadimg),
				"encryptId":    se.EncodeString(util.BsonIdToSId((*user)["_id"])),
			})
			(*user)["shareid"] = shareid
			nick := fmt.Sprint((*user)["s_nickname"])
			f.SetSession("nickname", nick)
			f.SetSession("s_nickname", nick)
			f.SetSession("s_m_openid", fmt.Sprint((*user)["s_m_openid"]))
			f.SetSession("user", *user)
		} else {
			f.ServeJson(map[string]string{
				"result": "fail",
			})
		}
	} else {
		f.ServeJson(map[string]string{
			"result": "fail",
		})
	}
	return nil
}

//用户是否登录
func (f *Front) HasSign() error {
	tmp := f.Session().Get("user")
	openid := f.GetSession("s_m_openid")
	//log.Println(tmp, "___:", openid)
	if openid == nil {
		openid = ""
	}
	redisheadimg := redis.Get("other", "newUser-"+openid.(string))
	if redisheadimg == nil {
		redisheadimg = ""
	}
	if user, ok := tmp.(map[string]interface{}); ok {
		f.Session().Set("user", user)
		f.ServeJson(map[string]string{
			"result":       "ok",
			"s_nickname":   fmt.Sprint(user["s_nickname"]),
			"s_headimage":  fmt.Sprint(user["s_headimage"]),
			"redisheadimg": fmt.Sprint(redisheadimg),
			"encryptId":    se.EncodeString(util.BsonIdToSId(user["_id"])),
		})
	}
	return nil
}

//用户注销
func (f *Front) SignOut() error {
	f.DelSession("rpcBackUserInfo")
	f.DelSession("user")
	f.DelSession("s_nickname")
	f.DelSession("openid")
	f.DelSession("s_m_openid")
	f.ServeJson("ok")
	//sess := f.GetSession("user")
	//if user, ok := sess.(map[string]interface{}); ok {
	//shareid := fmt.Sprint(user["shareid"])
	//		redis.Del("sso", "p_usershare_"+shareid)
	//		//重新生成二维码，
	//		id, _ := strconv.Atoi(shareid)
	//		tools.GetShareQR(uint32(id))
	//
	//		expires := time.Now().Add(-2 * time.Hour)
	//		log.Println("exp:", expires)
	//		cookie := &http.Cookie{
	//			Name:     "userid_secure",
	//			Value:    "",
	//			Path:     "/",
	//			HttpOnly: true,
	//			MaxAge:   0,
	//			Expires:  expires,
	//		}
	//		log.Println("cookie:", cookie)
	//		f.SetCookie(cookie)
	//}
	return nil
}

//微信公众号获取数字
func (f *Front) GetLoginNum(prestr string) error {
	var oid = f.GetString("oid")
	var Rref = f.GetString("rref")
	f.SetSession("Rref", Rref)
	shareid, shareidot := qrmanager.QrCodeManager.GetQRCode(oid, prestr, f.Session(), f.Request)
	//log.Println("登录获取shareid:", shareid)
	f.ServeJson(map[string]string{
		"num":   se.EncodeString(shareid),
		"numot": se.EncodeString(shareidot),
	})
	return nil
}

//
func (m *Front) Lifirst() {
	defer util.Catch()
	myopenid, _ := m.Session().Get("s_m_openid").(string)
	if m.GetSession("shfirst") == "F" && myopenid != "" {
		mongodb.Update("user", bson.M{"s_m_openid": myopenid}, bson.M{"$set": bson.M{"s_shfirst": "N"}}, false, false)
	}
}

//一键报告
func (m *Front) Onekey() error {
	defer util.Catch()
	fkid := util.DecodeArticleId2ByCheck(m.GetString("fkid"))[0]
	//onekeyid := redis.Get("other", "onekey_"+fkid)
	flag := "N"
	data := make(map[string]interface{})
	//if onekeyid == nil {
	if fkid != "" {
		//intdata, _ := mongodb.FindOne("interaction", `{"s_fkid":"`+fkid+`","i_type":7}`)
		//if len(*intdata) == 0 {
		userId, _ := m.GetSession("userId").(string)
		if userId != "" {
			userInfo, _ := mongodb.FindById("user", userId, nil)
			if (*userInfo)["s_nickname"] != nil { //昵称
				data["s_username"] = (*userInfo)["s_nickname"].(string)
			} else if (*userInfo)["s_name"] != nil { //s_name
				data["s_username"] = (*userInfo)["s_name"].(string)
			}
			if (*userInfo)["s_name"] != nil {
				data["s_submitname"] = (*userInfo)["s_name"].(string)
			}
			data["s_submitid"] = userId
		}
		data["i_type"] = 7
		value := m.GetString("value")
		value = strings.Replace(value, "'", "&qpos;", 1)
		if len([]rune(value)) > 200 {
			value = util.SubString(value, 0, 200)
		}
		data["s_remark"] = "剑鱼-一键报告排版问题\n" + value
		data["s_mop"] = m.GetString("mop") //来源：移动端or电脑端
		data["s_title"] = m.GetString("title")
		data["i_status"] = 0
		data["l_submitdate"] = time.Now().Unix()
		data["s_source"] = m.GetString("source")
		data["s_primaryhref"] = m.GetString("primaryhref")
		data["s_fkid"] = fkid
		id := mongodb.Save("interaction", data)
		if len(id) > 0 {
			flag = "Y"
		}
		//} else if (*intdata)["i_status"] == 1 {
		//			set := make(map[string]interface{})
		//			set["i_status"] = 0
		//			set["s_opinion"] = ""
		//			set["s_auditname"] = ""
		//			set["s_editorname"] = ""
		//			set["l_submitdate"] = time.Now().Unix()
		//			id := mongodb.Update("interaction", `{"s_fkid":"`+fkid+`","i_type":7}`, &map[string]interface{}{"$set": set}, false, false)
		//			if id {
		//				flag = "Y"
		//			}
		//}
		redis.Put("other", "onekey_"+fkid, fkid, 10*60)
	}
	//}
	m.ServeJson(map[string]interface{}{
		"flag": flag,
	})
	return nil
}

//
func (m *Front) Encrypt() error {
	defer util.Catch()
	id := m.GetString("id")
	s_openid := m.GetSession("s_m_openid")
	flag := "F"
	var sid_openid string
	util.Try(func() {
		if id != "" && s_openid != nil {
			id = util.DecodeArticleId2ByCheck(id)[0]
			sid_openid = util.EncodeArticleId2ByCheck(id, s_openid.(string))
			flag = "T"
		}
	}, func(e interface{}) {
		log.Println("分享短地址加密出错", e)
	})
	m.ServeJson(map[string]interface{}{
		"flag":       flag,
		"sid_openid": sid_openid,
	})
	return nil
}

//
func (m *Front) Wxkeywords() error {
	myopenid, _ := m.Session().Get("s_m_openid").(string)
	m.T["openid"] = se.EncodeString(myopenid)
	mynickname, _ := m.Session().Get("s_nickname").(string)
	myavatar, _ := m.Session().Get("s_avatar").(string)
	m.T["nickname"] = mynickname
	m.T["avatar"] = myavatar
	m.T["signature"] = wx.SignJSSDK(m.Site() + m.Url())
	return m.Render("/weixin/wxkeywords.html", &m.T)
}

//
func (m *Front) Wxerr() error {
	return m.Render("/_err.html")
}

//
func (m *Front) Wxscope() error {
	myopenid, _ := m.Session().Get("s_m_openid").(string)
	m.T["openid"] = se.EncodeString(myopenid)
	mynickname, _ := m.Session().Get("s_nickname").(string)
	myavatar, _ := m.Session().Get("s_avatar").(string)
	m.T["nickname"] = mynickname
	m.T["avatar"] = myavatar
	m.T["signature"] = wx.SignJSSDK(m.Site() + m.Url())
	return m.Render("/weixin/wxscope.html", &m.T)
}

//查找用户并创建session
func FindUserAndCreateSess(openid string, sess *httpsession.Session) (ok bool) {
	_person, ok := tools.MQFW.FindOne("user", bson.M{"s_m_openid": openid})
	if ok && *_person != nil && len(*_person) > 0 {
		person := *_person
		//加入session
		//		if person["i_know"] != nil {
		//			sess.Set("iknow", person["i_know"])
		//		}
		if person["i_shareknow"] != nil {
			sess.Set("shareknow", person["i_shareknow"])
		}
		sess.Set("userId", (person["_id"].(bson.ObjectId)).Hex())
		sess.Set("s_m_openid", person["s_m_openid"])
		sess.Set("openid", person["s_m_openid"])
		sess.Set("s_nickname", person["s_nickname"])
		sess.Set("s_avatar", person["s_avatar"])
		go updateUserPushStatus(openid)
	}
	return
}

//微信跳转创建session
func (m *Front) Sess(ostr string) error {
	defer util.Catch()
	strs := strings.Split(ostr, "__")
	str := strings.Split(sewx.DecodeString(strs[0]), ",")
	if len(str) == 4 {
		openid := str[0]
		ok := FindUserAndCreateSess(openid, m.Session())
		if ok {
			actionurl := util.ObjToString(urlMap[str[3]])
			if actionurl != "" {
				if len(strs) > 1 {
					if strings.Contains(actionurl, "followent/newInfo") {
						actionurl = fmt.Sprintf(actionurl, (strs[1] + "___" + strs[2]))
					} else {
						//支持多个参数%s..
						actionurl = fmt.Sprintf(actionurl, func(tmps []string) []interface{} {
							res := make([]interface{}, len(tmps))
							for k, v := range tmps {
								res[k] = v
							}
							return res
						}(strs[1:])...)
					}
				}
				m.Redirect(actionurl)
			} else {
				if !ok {
					log.Println("数据库连接超时！", openid)
				} else {
					log.Println("解析结果：", str, "，actionurl为空")
				}
				m.Render("_error.html")
			}
		} else {
			go tools.SaveAbnormal(openid)
			log.Println("没有找到该用户：", openid)
			m.Render("_error.html")
		}
	} else {
		log.Println("解析出错，解析结果：", str)
		m.Render("_error.html")
	}
	return nil
}

//修改用户推送的状态，i_ispush
//当用户有操作的时候，认为是可以收到推送的，修改i_ispush为1
func updateUserPushStatus(openid string) {
	set := bson.M{"$set": bson.M{"i_ispush": 1}}
	mongodb.Update("user", bson.M{"s_m_openid": openid}, set, false, true)
	mongodb.Update("follow_project", bson.M{"s_openid": openid}, set, false, true)
	mongodb.Update("jylab_followent", bson.M{"s_openid": openid}, set, false, true)
}

//删除模板缓存
func (d *Front) Delc(url string) {
	defer util.Catch()
	d.App.TemplateMgr.CacheDelete(strings.Replace(url, "GG", "/", 1))
	d.WriteBytes([]byte("ok,清除路径:" + url))
}

func (m *Front) Viewdemo() {
	m.Redirect("/swordfish/guide/-1")
}

//剑鱼用户协议
func (m *Front) Wxprotocol() error {
	return m.Render("/weixin/wxprotocol.html")
}

//此方法已经不用
//func (m *Front) Iknow() {
//	defer util.Catch()
//	if m.GetSession("userId") != nil {
//		mongodb.Update("user", bson.M{"_id": bson.ObjectIdHex(m.GetSession("userId").(string))}, `{"$set":{"i_know":1}}`, false, false)
//		m.SetSession("iknow", 1)
//		m.Write("1")
//	} else {
//		m.Write("0")
//	}
//}

//此方法已经不用
//func (m *Front) Aiknow() {
//	defer util.Catch()
//	if m.GetSession("userId") != nil {
//		mongodb.Update("user", bson.M{"_id": bson.ObjectIdHex(m.GetSession("userId").(string))}, `{"$set":{"i_shareknow":1}}`, false, false)
//		m.SetSession("shareknow", 1)
//		m.Write("1")
//	} else {
//		m.Write("0")
//	}
//}

//推送列表
func (m *Front) WxpushListInfo(_id string) error {
	defer util.Catch()
	if m.Session().Get("s_m_openid") == nil {
		return m.Redirect("/swordfish/share/-1")
	}
	tmp, ok := mongodb.FindById("wxpush", _id, nil)
	if ok {
		(*tmp)["bmatch"] = true
		m.T["data"] = &tmp
	} else {
		(*tmp)["bmatch"] = false
		m.T["data"] = &tmp

	}
	m.T["_id"] = _id
	m.T["signature"] = wx.SignJSSDK(m.Site() + m.Url())
	myopenid, _ := m.Session().Get("s_m_openid").(string)
	m.T["openid"] = se.EncodeString(myopenid)
	mynickname, _ := m.Session().Get("s_nickname").(string)
	myavatar, _ := m.Session().Get("s_avatar").(string)
	m.T["nickname"] = mynickname
	m.T["avatar"] = myavatar
	return m.Render("/weixin/wxpush.html", &m.T)
}
func (m *Front) Feedback() error {
	defer util.Catch()
	myopenid, _ := m.Session().Get("s_m_openid").(string)
	m.T["openid"] = se.EncodeString(myopenid)
	m.T["signature"] = wx.SignJSSDK(m.Site() + m.Url())
	userId, _ := m.GetSession("userId").(string)
	list, _ := mongodb.Find("interaction", bson.M{"s_submitid": userId}, `{"l_submitdate":-1}`, `{"s_remark":1,"l_submitdate":1,"s_opinion":1,"i_status":1}`, false, 0, 200)
	m.T["list"] = list
	fkid := m.GetString("fkid")
	if fkid != "" {
		fkid = util.DecodeArticleId2ByCheck(fkid)[0]
	}
	fromName := m.GetString("fromName")
	if fromName != "" {
		if fromName == "zndy" {
			fromName = "剑鱼实验室-智能订阅"
		} else if fromName == "sjdc" {
			fromName = "剑鱼实验室-数据导出"
		} else if fromName == "cjss" {
			fromName = "剑鱼实验室-超级搜索"
		} else if fromName == "zbqy" {
			fromName = "剑鱼实验室-中标企业"
		} else if fromName == "gzqy" {
			fromName = "剑鱼实验室-关注企业"
		}
	}
	util.ReadConfig(&config.Sysconfig)
	_, m.T["advertText"] = getRewardText()
	m.T["advertImg"] = config.Sysconfig["advertImg"]
	m.T["advertName"] = config.Sysconfig["advertName"]
	m.T["advertUrl"] = config.Sysconfig["advertUrl"]
	m.T["fkid"] = fkid
	m.T["fromName"] = fromName
	return m.Render("/weixin/feedback.html", &m.T)
}

func (m *Front) GetIndexData() {
	defer util.Catch()
	redis_obj := redis.Get("other", "sw_index")
	var one map[string]interface{}
	if redis_obj != nil {
		one = redis_obj.(map[string]interface{})
		log.Println("newpage from the cache...")
	} else {
		rs, err := mongodb.Find("swordfish_index", nil, `{"_id":-1}`, nil, false, 0, 1)
		if err {
			one = (*rs)[0]
			one["i_site"] = util.IntAll(one["i_entsite"]) + util.IntAll(one["i_govsite"])
			avg := util.IntAll(one["i_bidmonth"])/21 + util.IntAll(one["i_bidmonth"])%21
			one["i_avg"] = avg
			one["i_my"] = util.IntAll(one["i_entsite"]) * 35 / 100
			one["i_hy"] = util.IntAll(one["i_entsite"]) * 15 / 100
			one["i_zb"] = util.IntAll(one["i_entsite"]) - util.IntAll(one["i_my"]) - util.IntAll(one["i_hy"])
			redis.Put("other", "sw_index", one, 60*60*2)
		} else {
			m.ServeJson("n")
		}
	}
	userid := m.GetSession("userId")
	if userid != nil {
		sess := mongodb.GetMgoConn()
		defer mongodb.DestoryMongoConn(sess)
		var res bson.M
		sess.DB("qfw").C("wxpush").Pipe([]bson.M{bson.M{"$match": bson.M{"s_uid": userid}},
			bson.M{"$group": bson.M{"_id": "sum", "totalAmount": bson.M{"$sum": "$i_size"}}}}).One(&res)
		one["i_me"] = util.IntAll(res["totalAmount"])
	}
	m.ServeJson(one)
}

func (m *Front) Urlrecord() {
	m.Render("/weixin/urlrecord.html")
}
func (m *Front) Isrecord(name string) {
	defer util.Catch()
	querystr := `{"$or":[{"s_name":"%s"},{"s_url":"%s"}]}`
	if name != "" {
		rs, _ := mongodb.Find("bidurlinfo", fmt.Sprintf(querystr, name, name), nil, nil, false, -1, -1)
		if len(*rs) == 0 {
			m.Write("f")
		} else {
			m.Write("y")
		}
	} else {
		m.Write("n")
	}
}

//招标订阅向导
func (f *Front) TSGuide() error {
	defer util.Catch()
	s_openId := f.GetSession("s_m_openid")
	if s_openId == nil {
		return f.Redirect("/swordfish/share/-1")
	}
	openId, _ := s_openId.(string)
	if f.Method() == "GET" {
		if !isInTSguide(openId) {
			return f.Redirect("/wxkeyset/keyset/index")
		}
		f.T["signature"] = wx.SignJSSDK(f.Site() + f.Url())
		return f.Render("/weixin/wxtsguide.html")
	} else {
		reqType := f.GetString("reqType")
		result := make(bson.M)
		if reqType == "save" {
			var keyMaps []map[string]interface{}
			keyWord := f.GetSlice("keyWord")
			for _, v := range keyWord {
				vs := processKeyword(v)
				if vs == nil {
					continue
				}
				keyMaps = append(keyMaps, map[string]interface{}{
					"key": vs,
				})
				if len(keyMaps) >= 10 {
					break
				}
			}
			saveData := bson.M{
				"o_jy.a_key":        keyMaps,
				"o_jy.l_modifydate": time.Now().Unix(),
				"i_ts_guide":        2,
			}
			result["flag"] = mongodb.Update("user", bson.M{"s_m_openid": openId}, bson.M{"$set": saveData}, false, false)
		} else if reqType == "over" {
			mongodb.Update("user", bson.M{"s_m_openid": openId}, bson.M{"$set": bson.M{"i_ts_guide": 1}}, false, false)
		} else if reqType == "preview" {
			result["data"] = elastic.GetByNgram(INDEX, TYPE, strings.Split(f.GetString("key"), " "), "", FINDF, `{"publishtime":-1}`, `"_id","title","publishtime","toptype","subtype","type","area","href","areaval"`, 0, 10)
		}
		f.ServeJson(result)
	}
	return nil
}

func isInTSguide(openId string) bool {
	if openId == "" {
		return false
	}
	data, ok := mongodb.FindOneByField("user", bson.M{"s_m_openid": openId}, `{"o_jy":1,"i_ts_guide":1}`)
	if ok {
		o_jy, _ := (*data)["o_jy"].(map[string]interface{})
		i_ts_guide := util.IntAll((*data)["i_ts_guide"])
		if i_ts_guide == 2 || (i_ts_guide == 0 && len(o_jy) == 0) {
			return true
		}
	}
	return false
}

//查看原文中转
func (f *Front) Transfer() error {
	return f.Redirect(f.GetString("url"))
}

//关于我们
func (f *Front) Aboutus() error {
	if ret := redis.Get("other", "aboutus"); ret != nil {
		return f.SetBody([]byte(ret.(string)))
	} else {
		var shareid = f.GetString("id")
		if len(shareid) == 0 {
			shareid = "10" //fmt.Sprintf("%s%d", config.Seoconfig["jygywmy"].(string)+fmt.Sprintf("%d", time.Now().UnixNano())[7:14], rand.Intn(9))
		}
		f.T["logid"] = config.Seoconfig["jygywmy"].(string)
		f.T["shareid"] = se.EncodeString(shareid)
		content, _ := f.Render4Cache("/pc/aboutus.html", &f.T)
		redis.Put("other", "aboutus", string(content), -1)
		return f.SetBody(content)
	}
}

//商务合作
func (f *Front) Busicooperation() error {
	var shareid = f.GetString("id")
	if len(shareid) == 0 {
		shareid = "10" //fmt.Sprintf("%s%d", config.Seoconfig["jyswhzy"].(string)+fmt.Sprintf("%d", time.Now().UnixNano())[7:14], rand.Intn(9))
	}
	f.T["logid"] = config.Seoconfig["jyswhzy"].(string)
	f.T["shareid"] = se.EncodeString(shareid)
	content, _ := f.Render4Cache("/pc/businesscooperation.html", &f.T)
	return f.SetBody(content)
}

func (f *Front) Gethotkey() error {
	keys := []interface{}{}
	tmp := redis.Get("sso", "jy_hotkeys")
	if tmp != nil {
		keys = tmp.([]interface{})
	} else {
		list, _ := mongodb.Find("user", `{"o_jy.a_key":{$exists:true}}`, nil, `{"o_jy":1}`, false, -1, -1)
		keymap := map[string]int{}
		for _, user := range *list {
			if o_jy, ok := user["o_jy"].(map[string]interface{}); ok {
				a_key, _ := o_jy["a_key"].([]interface{})
				for _, v := range a_key {
					if tmp, ok := v.(map[string]interface{}); ok {
						keys := tmp["key"].([]interface{})
						for _, val := range keys {
							keymap[fmt.Sprint(val)] += 1
						}
					}
				}
			}
		}
		keylist := []*jyutil.ObjectMap{}
		for k, v := range keymap {
			obj := &jyutil.ObjectMap{}
			obj.Key = k
			obj.Num = v
			keylist = append(keylist, obj)
		}
		keylist = jyutil.SortMap(keylist)
		for k, v := range keylist {
			if k < 6 {
				keys = append(keys, v.Key)
			} else {
				break
			}
		}
		redis.Put("sso", "jy_hotkeys", keys, 7*24*60*60)
	}
	f.ServeJson(keys)
	return nil
}

//redis存储用户搜索关键词 企业 项目信息

func (f *Front) Rediskw() error {
	skw := f.GetString("skw")
	num := f.GetString("num")
	if skw != "" && num != "" {
		num = se.DecodeString(num)
		redis.Put("sso", "pc_subscribe_"+num, skw, 15*60)
	}
	return nil
}