package releases

import (
    "fmt"
    "os"
    "path/filepath"
    "mime/multipart"
    "io"
    "encoding/json"
    "net/http"
    "bytes"

    "oc-publish/occonst"
)

type assetStruct struct {
    Name string `json:"name"`
    Id int `json:"id"`
}

func GetAssetId(idRelease int, name string) (int, error) {
    url := fmt.Sprintf("%s/api/v1/repos/%s/releases/%d/assets",
                        occonst.PUBLISH_URL,
                        occonst.PUBLISH_VERSION,
                        idRelease)

    res, err := http.Get(url)
    if err != nil {
        return -1, err
    }
    body, err := io.ReadAll(res.Body)
    if err != nil {
        return -2, err
    }

    var data []assetStruct

    err = json.Unmarshal(body, &data)
    fmt.Println(err)
    if err != nil {
        return -3, err
    }

    for _, ele := range data {
        if ele.Name == name {
            return ele.Id, nil
        }
    }
    return 0, nil
}

// curl -X 'POST' \
//   'https://cloud.o-forge.io/api/v1/repos/core/oc-deploy/releases/2/assets?name=zzzz' \
//   -H 'accept: application/json' \
//   -H 'Content-Type: multipart/form-data' \
//   -F 'attachment=oc-deploy'
func CreateAsset(idRelease int, filename string) (int, error) {
    url := fmt.Sprintf("%s/api/v1/repos/%s/releases/%d/assets?name=%s&token=%s",
                        occonst.PUBLISH_URL,
                        occonst.PUBLISH_VERSION,
                        idRelease,
                        "name",
                        occonst.PUBLISH_TOKEN)
    
    // request, err := newfileUploadRequest(url, extraParams, "file", "/tmp/doc.pdf")

    err := uploadFile(url, "attachment", filename)
    fmt.Println(url, err)


    // fmt.Println(url)

    // body := []byte("CONTENU")
    // req, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
    // if err != nil {
    //     return -1, err
    // }
    // req.Header.Add("accept", "application/json")
    // req.Header.Add("Content-Type", "multipart/form-data")

    // client := &http.Client{}
    // res, err := client.Do(req)
    // fmt.Println(res, err)

    // cnt, err := io.ReadAll(res.Body)
    // fmt.Println(string(cnt), err)

    // if err != nil {
    //     return -1, err
    // }

    // if err != nil {
    //     return -2, err
    // }

    // defer res.Body.Close()
    
    return 0, nil
}

func uploadFile(url string, paramName string, filePath string) error {
    file, err := os.Open(filePath)
    if err != nil {
      return err
    }
    defer file.Close()
  
    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile(paramName, filepath.Base(filePath))
    if err != nil {
      return err
    }
    _, err = io.Copy(part, file)
  
    err = writer.Close()
    if err != nil {
      return err
    }
  
    request, err := http.NewRequest("POST", url, body)
    request.Header.Add("Content-Type", writer.FormDataContentType())
    request.Header.Add("accept", "application/json")
    client := &http.Client{}
    response, err := client.Do(request)
  
    if err != nil {
      return err
    }
    defer response.Body.Close()
  
    cnt, err := io.ReadAll(response.Body)
    fmt.Println(string(cnt), err, writer.FormDataContentType())

    // Handle the server response...
    return nil
  }


// func newfileUploadRequest(uri string, params map[string]string, paramName, path string) (*http.Request, error) {
// 	file, err := os.Open(path)
// 	if err != nil {
// 		return nil, err
// 	}
// 	defer file.Close()

// 	body := &bytes.Buffer{}
// 	writer := multipart.NewWriter(body)
// 	part, err := writer.CreateFormFile(paramName, filepath.Base(path))
// 	if err != nil {
// 		return nil, err
// 	}
// 	_, err = io.Copy(part, file)

// 	// for key, val := range params {
// 	// 	_ = writer.WriteField(key, val)
// 	// }
// 	// err = writer.Close()
// 	// if err != nil {
// 	// 	return nil, err
// 	// }

// 	req, err := http.NewRequest("POST", uri, body)
// 	req.Header.Set("Content-Type", writer.FormDataContentType())
// 	return req, err
// }