Untitled

func LoadFileFromURL(inputURL string) (beep.Streamer, beep.Format, error) {
	resp, err := http.Head(inputURL)
	if err != nil {
		fmt.Println("Head URL failed")
		return nil, beep.Format{}, err
	}
	contentType := resp.Header.Get("Content-Type")
	if !isAudioContentType(contentType) {
		panic("URL does not point to an audio resource")
	}
	defer resp.Body.Close()
	response, errGet := http.Get(inputURL)
	if errGet != nil {
		fmt.Println("Get URL failed")
		return nil, beep.Format{}, errGet
	}
	defer response.Body.Close()
	streamer, format, errDecode := mp3.Decode(response.Body)
	if errDecode != nil {
		fmt.Println("Decode failed")
		fmt.Println(errDecode.Error())
		return nil, beep.Format{}, errDecode
	}
	// defer streamer.Close()
	err = speaker.Init(format.SampleRate, format.SampleRate.N(time.Second/10))
	if err != nil {
		fmt.Println("Init failed")
		return nil, beep.Format{}, err
	}
	return streamer, format, nil
}

func MixTwoAudio(source1, source2 string) (beep.Streamer, error) {
	fmt.Println(source1)
	fmt.Println(source2)
	streamer1, format1, err := LoadFileFromURL(source1)
	if err != nil {
		log.Fatal("Load file failed")
		return nil, err
	}
	streamer2, format2, err := LoadFileFromURL(source2)
	if err != nil {
		log.Fatal("Load file failed")
		return nil, err
	}
	//
	if format1.SampleRate != format2.SampleRate {
		log.Fatal("Difference SampleRate")
		return nil, errors.New("Difference SampleRate")
	}

	speaker.Init(format1.SampleRate, format1.SampleRate.N(time.Second/10))

	// Mix the two audio streams.
	mixedStreamer := beep.Mix(streamer1, streamer2)

	return mixedStreamer, nil
	
}
func ReadFilesFromFolder(folder string) ([]string, error) {
	endpoint := "upload-static.fpt.net:80"
	accessKeyID := "aGktZnB0"
	secretAccessKey := "WHl6aGlmcHQxMjM="
	bucketName := "sys"
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: false,
	})
	if err != nil {
		log.Fatal(err)
		return nil, err
	}
	objectCh := minioClient.ListObjects(context.Background(), bucketName, minio.ListObjectsOptions{
		Prefix:    "hifpt/pnc_pdx/record_call_stag/" + folder,
		Recursive: true,
	})
	var results []string
	rootURL := "https://hi-static.fpt.vn/sys/"
	for object := range objectCh {
		if object.Err != nil {
			fmt.Println(object.Err)
			return nil, object.Err
		}
		results = append(results, rootURL+object.Key)
	}
	return results, nil
}
func AppendSingleCall(folder string) { //"2023-07-27"

	listInput, err := ReadFilesFromFolder(folder)
	if err != nil {
		log.Fatal(err)
		return
	}
	// get list caller and list callee

	var listCaller []string
	var listCallee []string
	for _, record := range listInput {
		if strings.Contains(record, "caller") {
			listCaller = append(listCaller, record)
		} else if strings.Contains(record, "callee") {
			listCallee = append(listCallee, record)
		}
	}
	sort.Strings(listCaller)
	sort.Strings(listCallee)
	//
	fmt.Println(len(listCallee))
	fmt.Println(len(listCaller))
	//
	// ********************************************* TODO: Append Audio after mixed
	// var final beep.Streamer
	// for i := 0; i < len(listCallee); i++ {
	// 	fmt.Println(i)
	// 	temp, err := MixTwoAudio(listCallee[i], listCaller[i])
	// 	if err != nil {
	// 		panic(err)
	// 	}
	// 	if i == 0 {
	// 		final = temp
	// 		continue
	// 	}
	// 	final = beep.Seq(final, temp)
	// }
    // ********************** TODO: Test mixing
	_, format, _ := LoadFileFromURL(listCallee[0])

	outputFile, err := os.Create("output.mp3")
	if err != nil {
		panic(err)
	}
	defer outputFile.Close()
	final, errFinal := MixTwoAudio(listCallee[0], listCaller[0])
	if errFinal != nil {
		panic(err)
	}
	if err := wav.Encode(outputFile, final, format); err != nil {
		panic(err)
	}
	fmt.Println("Audio fetched and saved successfully")
}
func main(){
    AppendSingleCall("2023-08-14/d06c97be-bbfe-49ba-8e36-b57c1011aba5eee") //TODO: Append 1 call
}


// *************************** TODO: Test Local
func loadMP3File(filename string) (beep.Streamer, beep.Format, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, beep.Format{}, err
	}
	streamer, format, err := mp3.Decode(f)
	if err != nil {
		return nil, beep.Format{}, err
	}
	return streamer, format, nil
}
// ************************** TODO: Download file from URL 
func downloadFile(url, filename string) error {
	response, err := http.Get(url)
	if err != nil {
		return err
	}
	defer response.Body.Close()

	file, err := os.Create(filename)
	if err != nil {
		return err
	}
	defer file.Close()

	_, err = io.Copy(file, response.Body)
	if err != nil {
		return err
	}

	return nil
}