package worker

import (
	"encoding/json"
	"film/base/httputil"
	"film/config"
	"film/model"
	log "github.com/sirupsen/logrus"
	"github.com/smbrave/goutil"
	"github.com/spf13/cast"
	"gitlab.com/jiangyong27/gobase/wxapi"
	"strings"
	"time"
)

type Dadi struct {
	Token    string
	citys    map[string]*DadiCity
	qyClient *wxapi.WxQiye
}

func (d *Dadi) Init() error {
	cityUrl := "https://appapi.dadicinema.com/app-web/v1/web/cinema/cbticket/cbase/cityAndCinemaList"

	params := d.getCinemaReq(&DadiCinema{
		Name:        "大地影院（北京十里河铭泽店）",
		Id:          118,
		UnifiedCode: 11050621,
	})
	body, err := httputil.HttpGet(cityUrl, params, map[string]string{
		"User-Agent": "apifox/1.0.0 (https://www.apifox.cn)",
	})

	result := make(map[string]interface{})
	if err := json.Unmarshal(body, &result); err != nil {
		log.Errorf("json.unmarshal [%s] error : %s", string(body), err.Error())
		return err
	}
	if cast.ToInt(result["code"]) != 200 || cast.ToBool(result["success"]) != true {
		log.Errorf("code[%d] message[%s]", cast.ToInt(result["code"]), cast.ToString(result["msg"]))
		return err
	}

	citys := make(map[string]*DadiCity)
	datas := cast.ToSlice(result["data"])

	for _, d := range datas {
		data := cast.ToStringMap(d)

		cinemas := make([]*DadiCinema, 0)
		for _, c := range cast.ToSlice(data["cinemas"]) {
			cin := cast.ToStringMap(c)
			cinema := new(DadiCinema)
			cinema.Name = cast.ToString(cin["name"])
			cinema.Address = cast.ToString(cin["address"])
			cinema.Latitude = cast.ToString(cin["latitude"])
			cinema.Longitude = cast.ToString(cin["longitude"])
			cinema.CityId = cast.ToInt64(cin["cityId"])
			cinema.UnifiedCode = cast.ToInt64(cin["unifiedCode"])
			cinemas = append(cinemas, cinema)
		}
		cityInfo := cast.ToStringMap(data["cityInfo"])
		city := new(DadiCity)
		city.Name = cast.ToString(cityInfo["chName"])
		city.ShortName = cast.ToString(cityInfo["shortName"])
		city.CityId = cast.ToInt64(data["cityId"])
		city.CityCode = cast.ToInt64(data["cityCode"])
		city.Cinemas = cinemas

		citys[city.ShortName] = city
	}

	d.citys = citys
	log.Infof("load dadi citys : %d", len(d.citys))

	cfg := config.GetConfig()
	d.qyClient = wxapi.NewQiye(&wxapi.QiyeConfig{
		Corpid: cfg.Weixin.QiyeAppid,
		Secret: cfg.Weixin.Qiyesecret,
		Sender: cfg.Weixin.QiyeAgent,
	})
	return nil
}

func (d *Dadi) NewOrder(order *model.Order) {
	if _, ok := d.citys[order.CityName]; !ok {
		log.Errorf("city[%s] not exist dadi cinema", order.CityName)
		return
	}
	city := d.citys[order.CityName]
	for _, cinema := range city.Cinemas {
		if cinema.Name != order.CinemaName {
			continue
		}

		films, err := d.getCinemaFilm(cinema)
		if err != nil {
			log.Errorf("getCinemaFilm cinema : %s error :%s", goutil.EncodeJSON(cinema), err.Error())
			continue
		}
		if _, ok := films[order.MovieName]; !ok {
			log.Errorf("cinema[%s] not movie[%s] ", cinema.Name, order.MovieName)
			continue
		}
		film := films[order.MovieName]

		orderShowDay := time.Unix(order.ShowTime, 0).Format("2006-01-02")
		var show *DadiFilmShow = nil
		for _, sh := range film.Shows {
			if sh.Day != orderShowDay {
				continue
			}
			show = sh
		}
		if show == nil {
			log.Errorf("cinema[%s] movie[%s] no day[%s]", cinema.Name, order.MovieName, orderShowDay)
			continue
		}

		message := make([]string, 0)
		message = append(message, "【匹配成功】")
		message = append(message, "订单信息：%s", goutil.EncodeJSON(order))
		message = append(message, "影院信息：%s", goutil.EncodeJSON(cinema))
		message = append(message, "电影信息：%s", goutil.EncodeJSON(film))
		if err := d.qyClient.SendText([]string{"jiangyong"}, strings.Join(message, "\n")); err != nil {
			log.Errorf("send message error : %s", err.Error())
		}
	}
}

func (d *Dadi) getCinemaReq(cinema *DadiCinema) map[string]string {
	params := map[string]string{
		"channelCode":       "SYH-DDZY-DD",
		"channelName":       "大地自营-大地",
		"channelNo":         "SYH-DDZY-DD",
		"channelUid":        "SYH-DDZY-DD",
		"cinema":            cast.ToString(cinema.UnifiedCode),
		"cinemaCode":        cast.ToString(cinema.UnifiedCode),
		"cinemaUid":         cast.ToString(cinema.Id),
		"d":                 "iPhone14,3",
		"i":                 "00000000-0000-0000-0000-000000000000",
		"k":                 d.Token,
		"r":                 "1",
		"s":                 "iOS15.2.1",
		"t":                 "1",
		"tenantId":          "321566",
		"unifiedCinemaId":   cast.ToString(cinema.Id),
		"unifiedCinemaName": cinema.Name,
		"unifiedCode":       cast.ToString(cinema.UnifiedCode),
		"v":                 "8.7.3",
	}
	return params
}

func (d *Dadi) UpdateOrder(order *model.Order) {

}

func (d *Dadi) getCinemaFilm(cinema *DadiCinema) (map[string]*DadiFilm, error) {
	baseReq := d.getCinemaReq(cinema)
	reqUrl := "https://appapi.dadicinema.com/app-web/v1/web/film/getHitFilmAndFilmSession"
	body, err := httputil.HttpGet(reqUrl, baseReq, map[string]string{
		"User-Agent": "apifox/1.0.0 (https://www.apifox.cn)",
	})
	if err != nil {
		log.Errorf("httpGet[%s] error : %s", reqUrl, err.Error())
		return nil, err
	}

	result := make(map[string]interface{})
	if err := json.Unmarshal(body, &result); err != nil {
		log.Errorf("json.unmarshal [%s] error : %s", string(body), err.Error())
		return nil, err
	}
	if cast.ToInt(result["code"]) != 200 || cast.ToBool(result["success"]) != true {
		log.Errorf("code[%d] message[%s]", cast.ToInt(result["code"]), cast.ToString(result["msg"]))
		return nil, err
	}

	films := make(map[string]*DadiFilm)

	for _, f := range cast.ToSlice(cast.ToStringMap(result["data"])["filmList"]) {
		film := new(DadiFilm)
		ff := cast.ToStringMap(f)
		film.Id = cast.ToInt64(ff["id"])
		film.Name = cast.ToString(ff["name"])
		film.Shows = make([]*DadiFilmShow, 0)
		for _, s := range cast.ToSlice(ff["showList"]) {
			ss := cast.ToStringMap(s)
			show := new(DadiFilmShow)
			show.Day = cast.ToString(ss["dayStr"])
			show.Halls = make([]*DadiFilmShowHall, 0)
			for _, p := range cast.ToSlice(ss["plist"]) {
				pp := cast.ToStringMap(p)
				hall := new(DadiFilmShowHall)
				hall.HallName = cast.ToString(pp["hallName"])
				hall.SessionId = cast.ToString(pp["sessionId"])
				hall.StartTime = cast.ToString(pp["startTime"])
				hall.EndTime = cast.ToString(pp["endTime"])
				show.Halls = append(show.Halls, hall)
			}
			film.Shows = append(film.Shows, show)
		}

		films[film.Name] = film
	}
	return films, nil
}

func (d *Dadi) checkSeats(cinema *DadiCinema, order *model.Order) {

	//baseReq := d.getCinemaReq(cinema)
}