package main

import (
	"bytes"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
)

type ConfidentialType string

const (
	ALL     ConfidentialType = "ALL"
	FRIENDS ConfidentialType = "FRIENDS"
	NOBODY  ConfidentialType = "NOBODY"
)

type ESAccount struct {
	DateOfBirth string
	Description string
	Follows     []string
	Followers   []string
}

func (a ESAccount) String() string {
	follows, _ := json.Marshal(a.Follows)
	followers, _ := json.Marshal(a.Followers)
	return fmt.Sprintf(`{ "date_of_birth": "%s", "description": "%s", "follows": %s, "followers": %s }`, a.DateOfBirth, a.Description, follows, followers)
}

type ESUser struct {
	ID           int
	Username     string
	FirstName    string
	LastName     string
	PictureURL   string
	Email        string
	Access       string
	TelegramID   string
	GoogleID     string
	Token        string
	Account      *ESAccount
	Confidencial map[string]ConfidentialType
}

func (u ESUser) String() string {
	return fmt.Sprintf(`{ "id": %d, "username": "%s", "first_name": "%s", "last_name": "%s", "picture_url": "%s", "email": "%s", "access": "%s", "telegram_id": "%s", "google_id": "%s" }`, u.ID, u.Username, u.FirstName, u.LastName, u.PictureURL, u.Email, u.Access, u.TelegramID, u.GoogleID)
}

type ESCleint struct {
	Token string
}

func (c *ESCleint) getSelf() (*ESUser, error) {
	url := "https://auth.easystartup.su/api/user/self"
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	account, err := c.getSelfAccount()
	if err != nil {
		return nil, err
	}

	confidencial, err := c.getSelfConfidential()
	if err != nil {
		return nil, err
	}

	return &ESUser{
		ID:           int(data["id"].(float64)),
		Username:     data["username"].(string),
		FirstName:    data["first_name"].(string),
		LastName:     data["last_name"].(string),
		PictureURL:   data["picture_url"].(string),
		Email:        data["email"].(string),
		Access:       data["access"].(string),
		TelegramID:   data["telegram_id"].(string),
		GoogleID:     data["google_id"].(string),
		Token:        c.Token,
		Account:      account,
		Confidencial: confidencial,
	}, nil
}

func (c *ESCleint) follow(id int) error {
	url := fmt.Sprintf("https://account.easystartup.su/api/following/follow/%d", id)
	req, err := http.NewRequest("PUT", url, nil)
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) unfollow(id int) error {
	url := fmt.Sprintf("https://account.easystartup.su/api/following/unfollow/%d", id)
	req, err := http.NewRequest("PUT", url, nil)
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) getSelfAccount() (*ESAccount, error) {
	url := "https://account.easystartup.su/api/account"
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	follows := []string{}
	if data["follows"] != nil {
		for _, f := range data["follows"].([]interface{}) {
			follows = append(follows, f.(string))
		}
	}

	followers := []string{}
	if data["followers"] != nil {
		for _, f := range data["followers"].([]interface{}) {
			followers = append(followers, f.(string))
		}
	}

	return &ESAccount{
		DateOfBirth: data["date_of_birth"].(string),
		Description: data["description"].(string),
		Follows:     follows,
		Followers:   followers,
	}, nil
}

func (c *ESCleint) editSelfAccount(user *ESUser) error {
	url := "https://account.easystartup.su/api/account"
	data := map[string]string{
		"date_of_birth": user.Account.DateOfBirth,
		"description":   user.Account.Description,
	}
	jsonData, _ := json.Marshal(data)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) editSelfConfidential(user *ESUser) error {
	url := "https://account.easystartup.su/api/confidential"
	data := user.Confidencial
	for k, v := range data {
		data[k] = v
	}
	jsonData, _ := json.Marshal(data)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) getSelfConfidential() (map[string]ConfidentialType, error) {
	url := "https://account.easystartup.su/api/confidential"
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]string
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	confidential := make(map[string]ConfidentialType)
	for k, v := range data {
		confidential[k] = ConfidentialType(v)
	}
	return confidential, nil
}

func (c *ESCleint) editSelf(user *ESUser) error {
	url := "https://auth.easystartup.su/api/user/self"
	data := map[string]string{
		"email":      user.Email,
		"first_name": user.FirstName,
		"last_name":  user.LastName,
		"username":   user.Username,
	}
	jsonData, _ := json.Marshal(data)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if err := c.editSelfAccount(user); err != nil {
		return err
	}
	if err := c.editSelfConfidential(user); err != nil {
		return err
	}

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) getAccount(id int) (*ESAccount, error) {
	url := fmt.Sprintf("https://account.easystartup.su/api/account/%d", id)
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	follows := []string{}
	if data["follows"] != nil {
		for _, f := range data["follows"].([]interface{}) {
			follows = append(follows, f.(string))
		}
	}

	followers := []string{}
	if data["followers"] != nil {
		for _, f := range data["followers"].([]interface{}) {
			followers = append(followers, f.(string))
		}
	}

	return &ESAccount{
		DateOfBirth: data["date_of_birth"].(string),
		Description: data["description"].(string),
		Follows:     follows,
		Followers:   followers,
	}, nil
}

func (c *ESCleint) editAccount(user *ESUser) error {
	url := fmt.Sprintf("https://account.easystartup.su/api/confidential/%d", user.ID)
	data := map[string]string{
		"date_of_birth": user.Account.DateOfBirth,
		"description":   user.Account.Description,
	}
	jsonData, _ := json.Marshal(data)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) editConfidential(user *ESUser) error {
	url := fmt.Sprintf("https://account.easystartup.su/api/confidential/%d", user.ID)
	data := user.Confidencial
	for k, v := range data {
		data[k] = v
	}
	jsonData, _ := json.Marshal(data)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) getConfidential(id int) (map[string]ConfidentialType, error) {
	url := fmt.Sprintf("https://account.easystartup.su/api/confidential/%d", id)
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]string
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	confidential := make(map[string]ConfidentialType)
	for k, v := range data {
		confidential[k] = ConfidentialType(v)
	}
	return confidential, nil
}

func (c *ESCleint) picture(file io.Reader) error {
	url := "https://account.easystartup.su/api/account/picture"
	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, err := writer.CreateFormFile("file", "pic.png")
	if err != nil {
		return err
	}
	if _, err := io.Copy(part, file); err != nil {
		return err
	}
	writer.Close()

	req, err := http.NewRequest("POST", url, body)
	if err != nil {
		return err
	}
	req.Header = c.headers()
	req.Header.Set("Content-Type", writer.FormDataContentType())

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) create(user *ESUser) (*ESUser, error) {
	url := "https://auth.easystartup.su/api/user/"
	jsn, _ := json.Marshal(user)

	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsn))
	if err != nil {
		return nil, err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	account, err := c.getAccount(int(data["id"].(float64)))
	if err != nil {
		return nil, err
	}

	confidencial, err := c.getConfidential(int(data["id"].(float64)))
	if err != nil {
		return nil, err
	}

	return &ESUser{
		ID:           int(data["id"].(float64)),
		Username:     data["username"].(string),
		FirstName:    data["first_name"].(string),
		LastName:     data["last_name"].(string),
		PictureURL:   data["picture_url"].(string),
		Email:        data["email"].(string),
		Access:       data["access"].(string),
		TelegramID:   data["telegram_id"].(string),
		GoogleID:     data["google_id"].(string),
		Token:        c.Token,
		Account:      account,
		Confidencial: confidencial,
	}, nil
}

func (c *ESCleint) edit(user *ESUser) error {
	url := fmt.Sprintf("https://auth.easystartup.su/api/user/%d", user.ID)
	jsn, _ := json.Marshal(user)

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsn))
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if err := c.editAccount(user); err != nil {
		return err
	}
	if err := c.editConfidential(user); err != nil {
		return err
	}

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) delete(user *ESUser) error {
	url := fmt.Sprintf("https://auth.easystartup.su/api/user/%d", user.ID)
	req, err := http.NewRequest("DELETE", url, nil)
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	url = fmt.Sprintf("https://auth.easystartup.su/api/account/%d", user.ID)
	req, err = http.NewRequest("DELETE", url, nil)
	if err != nil {
		return err
	}
	req.Header = c.headers()

	response, err = http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}
	return nil
}

func (c *ESCleint) users(start int, limit int) ([]interface{}, error) {
	url := fmt.Sprintf("https://auth.easystartup.su/api/user/all?start=%d&limit=%d", start, limit)
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data []interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}
	return data, nil
}

func (c *ESCleint) public(id int) ([]interface{}, error) {
	url := fmt.Sprintf("https://account.easystartup.su/api/public/%d", id)
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data []interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}
	return data, nil
}

func (c *ESCleint) usersCount() (int, error) {
	url := "https://auth.easystartup.su/api/user/count"
	response, err := http.Get(url)
	if err != nil {
		return 0, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return 0, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]int
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return 0, err
	}
	return data["count"], nil
}

func (c *ESCleint) get(id int) (*ESUser, error) {
	url := fmt.Sprintf("https://auth.easystartup.su/api/user/%d", id)
	response, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	if response.StatusCode != 200 {
		return nil, errors.New("Bad response code: " + fmt.Sprint(response.StatusCode))
	}

	var data map[string]interface{}
	if err := json.NewDecoder(response.Body).Decode(&data); err != nil {
		return nil, err
	}

	account, err := c.getAccount(int(data["id"].(float64)))
	if err != nil {
		return nil, err
	}

	confidencial, err := c.getConfidential(int(data["id"].(float64)))
	if err != nil {
		return nil, err
	}

	return &ESUser{
		ID:           int(data["id"].(float64)),
		Username:     data["username"].(string),
		FirstName:    data["first_name"].(string),
		LastName:     data["last_name"].(string),
		PictureURL:   data["picture_url"].(string),
		Email:        data["email"].(string),
		Access:       data["access"].(string),
		TelegramID:   data["telegram_id"].(string),
		GoogleID:     data["google_id"].(string),
		Token:        c.Token,
		Account:      account,
		Confidencial: confidencial,
	}, nil
}

func (c *ESCleint) headers() map[string]string {
	return map[string]string{
		"Authorization": "Bearer " + c.Token,
		"User-Agent":    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36 Edg/129.0.0.0",
		"Accept":        "application/json",
	}
}