package business

import (
	"encoding/json"
	"fmt"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"wss-pool/config"
	"wss-pool/internal"
	"wss-pool/internal/data"
	"wss-pool/logging/applogger"
	"wss-pool/pkg/model/stock"
)

/*
采集美股历史数据
一、日终数据
1、每日	daily
https://eodhistoricaldata.com/api/eod/0001.KLSE?api_token=647dd6744b94f4.20894198&period=d&fmt=json&from=2022-08-01&to=2023-06-15
2、每周	weekly
https://eodhistoricaldata.com/api/eod/MCD.US?api_token=647dd6744b94f4.20894198&period=w&fmt=json&from=2022-08-01&to=2023-06-15
3、每月	monthly
https://eodhistoricaldata.com/api/eod/MCD.US?api_token=647dd6744b94f4.20894198&period=m&fmt=json&from=2022-08-01&to=2023-06-15

二、日内数据
1、1小时	hour
https://eodhistoricaldata.com/api/intraday/AAPL.US?api_token=647dd6744b94f4.20894198&interval=1h&fmt=json&from=1659283200&to=1686815102
2、5分钟	fiveminutes
https://eodhistoricaldata.com/api/intraday/AAPL.US?api_token=647dd6744b94f4.20894198&interval=5m&fmt=json&from=1659283200&to=1686815102
3、1分钟	oneminute
https://eodhistoricaldata.com/api/intraday/AAPL.US?api_token=647dd6744b94f4.20894198&interval=1m&fmt=json
*/
func StockUsDaily() {
	filter := bson.M{"Country": "USA", "YesterdayClose": bson.M{"$ne": ""}, "BeforeClose": bson.M{"$ne": ""}}
	dateList, err := data.MgoFind(data.StockList, filter)
	if err != nil {
		applogger.Error("MgoFind info err: %v", err)
		return
	}
	for _, value := range dateList.([]primitive.M) {
		code := TypeCheck(value["Code"])
		applogger.Debug("code info: %v", code)
		codeUS := fmt.Sprintf("%v.US", code)
		// https://eodhistoricaldata.com/api/eod/0001.KLSE?api_token=647dd6744b94f4.20894198&period=d&fmt=json&from=2022-08-01&to=2023-06-15
		url := fmt.Sprintf("https://%v/api/eod/%v?api_token=%v&period=d&fmt=json&from=2022-08-01&to=2023-06-17",
			config.Config.ShareGather.FinancialHost, codeUS, config.Config.ShareGather.FinancialKey)
		bodyStr, err := internal.HttpGet(url)
		if err != nil {
			applogger.Error("Failed to query data：%v", err)
			return
		}
		fmt.Println(url)
		var eodModel []stock.EodData
		if err = json.Unmarshal([]byte(bodyStr), &eodModel); err != nil {
			applogger.Error("eodModel json Unmarshal err: %v", err)
			return
		}
		applogger.Info("data info: %v", eodModel)

		var bsonEod []interface{}
		for _, eodValue := range eodModel {
			bsonEod = append(bsonEod, bson.D{
				{"code", code},
				{"date", eodValue.Date},
				{"open", eodValue.Open},
				{"high", eodValue.High},
				{"low", eodValue.Low},
				{"close", eodValue.Close},
				{"adjusted_close", eodValue.AdjustedClose},
				{"volume", eodValue.Volume},
			})
		}

		if len(bsonEod) > 0 {
			if err := data.MgoInsertMany(data.StockUsDaily, bsonEod); err != nil {
				applogger.Error("MgoInsertMany info err: %v", err)
				return
			}
		}
	}
}

func StockUsWeekly() {
	filter := bson.M{"Country": "USA", "YesterdayClose": bson.M{"$ne": ""}, "BeforeClose": bson.M{"$ne": ""}}
	dateList, err := data.MgoFind(data.StockList, filter)
	if err != nil {
		applogger.Error("MgoFind info err: %v", err)
		return
	}

	for _, value := range dateList.([]primitive.M) {
		code := TypeCheck(value["Code"])
		applogger.Debug("code info: %v", code)
		codeUS := fmt.Sprintf("%v.US", code)
		// https://eodhistoricaldata.com/api/eod/MCD.US?api_token=647dd6744b94f4.20894198&period=w&fmt=json&from=2022-08-01&to=2023-06-15
		url := fmt.Sprintf("https://%v/api/eod/%v?api_token=%v&period=w&fmt=json&from=2022-08-01&to=2023-06-17",
			config.Config.ShareGather.FinancialHost, codeUS, config.Config.ShareGather.FinancialKey)
		bodyStr, err := internal.HttpGet(url)
		if err != nil {
			applogger.Error("Failed to query data：%v", err)
			return
		}

		var eodModel []stock.EodData
		if err = json.Unmarshal([]byte(bodyStr), &eodModel); err != nil {
			applogger.Error("eodModel json Unmarshal err: %v", err)
			return
		}
		applogger.Info("data info: %v", eodModel)
		var bsonEod []interface{}
		for _, eodValue := range eodModel {
			bsonEod = append(bsonEod, bson.D{
				{"code", code},
				{"date", eodValue.Date},
				{"open", eodValue.Open},
				{"high", eodValue.High},
				{"low", eodValue.Low},
				{"close", eodValue.Close},
				{"adjusted_close", eodValue.AdjustedClose},
				{"volume", eodValue.Volume},
			})
		}

		if len(bsonEod) > 0 {
			if err := data.MgoInsertMany(data.StockUsWeekly, bsonEod); err != nil {
				applogger.Error("MgoInsertMany info err: %v", err)
				return
			}
		}
	}
}

func StockUsMonthly() {
	filter := bson.M{"Country": "USA", "YesterdayClose": bson.M{"$ne": ""}, "BeforeClose": bson.M{"$ne": ""}}
	dateList, err := data.MgoFind(data.StockList, filter)
	if err != nil {
		applogger.Error("MgoFind info err: %v", err)
		return
	}

	for _, value := range dateList.([]primitive.M) {
		code := TypeCheck(value["Code"])
		applogger.Debug("code info: %v", code)
		codeUs := fmt.Sprintf("%v.US", code)
		// https://eodhistoricaldata.com/api/eod/MCD.US?api_token=647dd6744b94f4.20894198&period=m&fmt=json&from=2022-08-01&to=2023-06-17
		url := fmt.Sprintf("https://%v/api/eod/%v?api_token=%v&period=m&fmt=json&from=2022-08-01&to=2023-06-17",
			config.Config.ShareGather.FinancialHost, codeUs, config.Config.ShareGather.FinancialKey)
		bodyStr, err := internal.HttpGet(url)
		if err != nil {
			applogger.Error("Failed to query data：%v", err)
			return
		}

		var eodModel []stock.EodData
		if err = json.Unmarshal([]byte(bodyStr), &eodModel); err != nil {
			applogger.Error("eodModel json Unmarshal err: %v", err)
			return
		}
		applogger.Info("data info: %v", eodModel)
		var bsonEod []interface{}
		for _, eodValue := range eodModel {
			bsonEod = append(bsonEod, bson.D{
				{"code", code},
				{"date", eodValue.Date},
				{"open", eodValue.Open},
				{"high", eodValue.High},
				{"low", eodValue.Low},
				{"close", eodValue.Close},
				{"adjusted_close", eodValue.AdjustedClose},
				{"volume", eodValue.Volume},
			})
		}
		if len(bsonEod) > 0 {
			if err := data.MgoInsertMany(data.StockUsMonthly, bsonEod); err != nil {
				applogger.Error("MgoInsertMany info err: %v", err)
				return
			}
		}
	}
}

func StockUsHour() {
	filter := bson.M{"Country": "USA", "YesterdayClose": bson.M{"$ne": ""}, "BeforeClose": bson.M{"$ne": ""}}
	dateList, err := data.MgoFind(data.StockList, filter)
	if err != nil {
		applogger.Error("MgoFind info err: %v", err)
		return
	}

	for _, value := range dateList.([]primitive.M) {
		code := TypeCheck(value["Code"])
		applogger.Debug("code info: %v", code)
		codeUs := fmt.Sprintf("%v.US", code)
		// https://eodhistoricaldata.com/api/intraday/AAPL.US?api_token=647dd6744b94f4.20894198&interval=1h&fmt=json&from=1659283200&to=1686759266
		url := fmt.Sprintf("https://%v/api/intraday/%v?api_token=%v&interval=1h&fmt=json&from=1659283200&to=1686759266",
			config.Config.ShareGather.FinancialHost, codeUs, config.Config.ShareGather.FinancialKey)
		bodyStr, err := internal.HttpGet(url)
		if err != nil {
			applogger.Error("Failed to query data：%v", err)
			return
		}

		var eodModel []stock.IntraDayData
		if err = json.Unmarshal([]byte(bodyStr), &eodModel); err != nil {
			applogger.Error("eodModel json Unmarshal err: %v", err)
			return
		}
		applogger.Info("data info: %v", eodModel)
		var bsonEod []interface{}
		for _, eodValue := range eodModel {
			bsonEod = append(bsonEod, bson.D{
				{"code", code},
				{"timestamp", eodValue.Timestamp},
				{"gmtoffset", eodValue.Gmtoffset},
				{"datetime", eodValue.Datetime},
				{"open", eodValue.Open},
				{"high", eodValue.High},
				{"low", eodValue.Low},
				{"close", eodValue.Close},
				{"volume", eodValue.Volume},
			})
		}

		if len(bsonEod) > 0 {
			if err := data.MgoInsertMany(data.StockUsHour, bsonEod); err != nil {
				applogger.Error("MgoInsertMany info err: %v", err)
				return
			}
		}
	}
}

func StockUsFiveMinutes() {
	filter := bson.M{"Country": "USA", "YesterdayClose": bson.M{"$ne": ""}, "BeforeClose": bson.M{"$ne": ""}}
	dateList, err := data.MgoFind(data.StockList, filter)
	if err != nil {
		applogger.Error("MgoFind info err: %v", err)
		return
	}

	for _, value := range dateList.([]primitive.M) {
		code := TypeCheck(value["Code"])
		applogger.Debug("code info: %v", code)
		codeUs := fmt.Sprintf("%v.US", code)
		// https://eodhistoricaldata.com/api/intraday/AAPL.US?api_token=647dd6744b94f4.20894198&interval=5m&fmt=json&from=1659283200&to=1686815102
		url := fmt.Sprintf("https://%v/api/intraday/%v?api_token=%v&interval=5m&fmt=json&from=1659283200&to=1686759266",
			config.Config.ShareGather.FinancialHost, codeUs, config.Config.ShareGather.FinancialKey)
		bodyStr, err := internal.HttpGet(url)
		if err != nil {
			applogger.Error("Failed to query data：%v", err)
			return
		}

		var eodModel []stock.IntraDayData
		if err = json.Unmarshal([]byte(bodyStr), &eodModel); err != nil {
			applogger.Error("eodModel json Unmarshal err: %v", err)
			return
		}
		applogger.Info("data info: %v", eodModel)
		var bsonEod []interface{}
		for _, eodValue := range eodModel {
			bsonEod = append(bsonEod, bson.D{
				{"code", code},
				{"timestamp", eodValue.Timestamp},
				{"gmtoffset", eodValue.Gmtoffset},
				{"datetime", eodValue.Datetime},
				{"open", eodValue.Open},
				{"high", eodValue.High},
				{"low", eodValue.Low},
				{"close", eodValue.Close},
				{"volume", eodValue.Volume},
			})
		}
		if len(bsonEod) > 0 {
			if err := data.MgoInsertMany(data.StockUsFiveMinutes, bsonEod); err != nil {
				applogger.Error("MgoInsertMany info err: %v", err)
				return
			}
		}
	}
}

func StockUsOneMinute() {
	filter := bson.M{"Country": "USA", "YesterdayClose": bson.M{"$ne": ""}, "BeforeClose": bson.M{"$ne": ""}}
	dateList, err := data.MgoFind(data.StockList, filter)
	if err != nil {
		applogger.Error("MgoFind info err: %v", err)
		return
	}

	for _, value := range dateList.([]primitive.M) {
		code := TypeCheck(value["Code"])
		applogger.Debug("code info: %v", code)
		codeUs := fmt.Sprintf("%v.US", code)
		// https://eodhistoricaldata.com/api/intraday/AAPL.US?api_token=647dd6744b94f4.20894198&interval=1m&fmt=json
		url := fmt.Sprintf("https://%v/api/intraday/%v?api_token=%v&interval=1m&fmt=json",
			config.Config.ShareGather.FinancialHost, codeUs, config.Config.ShareGather.FinancialKey)
		bodyStr, err := internal.HttpGet(url)
		if err != nil {
			applogger.Error("Failed to query data：%v", err)
			return
		}

		var eodModel []stock.IntraDayData
		if err = json.Unmarshal([]byte(bodyStr), &eodModel); err != nil {
			applogger.Error("eodModel json Unmarshal err: %v", err)
			return
		}
		applogger.Info("data info: %v", eodModel)
		var bsonEod []interface{}
		for _, eodValue := range eodModel {
			bsonEod = append(bsonEod, bson.D{
				{"code", code},
				{"timestamp", eodValue.Timestamp},
				{"gmtoffset", eodValue.Gmtoffset},
				{"datetime", eodValue.Datetime},
				{"open", eodValue.Open},
				{"high", eodValue.High},
				{"low", eodValue.Low},
				{"close", eodValue.Close},
				{"volume", eodValue.Volume},
			})
		}
		if len(bsonEod) > 0 {
			if err := data.MgoInsertMany(data.StockUsOneMinute, bsonEod); err != nil {
				applogger.Error("MgoInsertMany info err: %v", err)
				return
			}
		}
	}
}