From c43e2ea434342e92138cf0f1d93b9294343f7f4c Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 14:30:21 +0530
Subject: [PATCH 01/36] cleanup and testing init

---
 server/party.go      | 20 ++++++++++++++++----
 server/party_test.go | 15 +++++++++++++++
 2 files changed, 31 insertions(+), 4 deletions(-)
 create mode 100644 server/party_test.go

diff --git a/server/party.go b/server/party.go
index ba7a4b2..70fa6ae 100755
--- a/server/party.go
+++ b/server/party.go
@@ -43,7 +43,16 @@ func createParty(id string, ownerId string, src string) *Party {
 
 func (p *Party) run() {
     log.Println("watchparty " + p.party.Id + " live.")
-    go p.broadcastStatus()
+    
+    done = make(chan bool)
+    go p.broadcastStatus(done)
+    
+    // watchparty will be terminated after this ticker ticks
+    ticker := time.NewTicker(24 * time.Hour)
+    defer func() {
+        done <-true // close broadcastStatus goroutine
+        ticker.Stop() // close watchparty
+    }()
 
     for {
         select {
@@ -81,16 +90,19 @@ func (p *Party) run() {
                 return true
             })
         }
+
+        case t := <-ticker.C:
+            // close the party after 24 hours
+            log.Prinf("Party %s terminated", p.party.Id)
+            return
     }
 }
 
-func (p *Party) broadcastStatus() {
+func (p *Party) broadcastStatus(done chan bool) {
     ticker := time.NewTicker(2000 * time.Millisecond)
-    done := make(chan bool)
 
     defer func() {
         ticker.Stop()
-        done <- true
         log.Printf("%s party ticker stopped\n", p.party.Id)
     }()
 
diff --git a/server/party_test.go b/server/party_test.go
new file mode 100644
index 0000000..b2964ca
--- /dev/null
+++ b/server/party_test.go
@@ -0,0 +1,15 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestRun() {
+	party := createParty("party-123", "user-123", "https://youtube.com")
+
+    go party.run()
+	// call create party
+	// party.run
+	// wait for end message
+}
\ No newline at end of file

From 21bcdec3784579eef2f0d143629520f30c8e126e Mon Sep 17 00:00:00 2001
From: dinosoupy <anishbasoup@gmail.com>
Date: Thu, 16 Nov 2023 20:09:45 +1100
Subject: [PATCH 02/36] test

---
 server/party.go      | 190 ++++++++++++++++++++++---------------------
 server/party_test.go |   7 +-
 2 files changed, 99 insertions(+), 98 deletions(-)

diff --git a/server/party.go b/server/party.go
index 70fa6ae..1b70155 100755
--- a/server/party.go
+++ b/server/party.go
@@ -8,110 +8,112 @@ import (
 )
 
 type PartyInfo struct {
-    Id          string      `json:"id"`
-    OwnerId     string      `json:"ownerId"`
-    Src         string      `json:"src"`
-    Playhead    float32     `json:"playhead"`
-    IsPlaying   bool        `json:"isPlaying"`
+	Id        string  `json:"id"`
+	OwnerId   string  `json:"ownerId"`
+	Src       string  `json:"src"`
+	Playhead  float32 `json:"playhead"`
+	IsPlaying bool    `json:"isPlaying"`
 }
 
 type Party struct {
-    party PartyInfo
-    //clients map[*Client]bool
-    clients sync.Map
-    broadcast chan []byte
-    join chan *Client
-    leave chan *Client
+	party PartyInfo
+	//clients map[*Client]bool
+	clients   sync.Map
+	broadcast chan []byte
+	join      chan *Client
+	leave     chan *Client
 }
 
 func createParty(id string, ownerId string, src string) *Party {
-    return &Party{
-        party: PartyInfo{
-            Id: id,
-            OwnerId: ownerId,
-            Src: src,
-            Playhead: 0,
-            IsPlaying: false,
-        },
-        //clients: make(map[*Client]bool),
-        clients: sync.Map{},
-        broadcast: make(chan []byte),
-        join: make(chan *Client),
-        leave: make(chan *Client),
-    }
+	return &Party{
+		party: PartyInfo{
+			Id:        id,
+			OwnerId:   ownerId,
+			Src:       src,
+			Playhead:  0,
+			IsPlaying: false,
+		},
+		//clients: make(map[*Client]bool),
+		clients:   sync.Map{},
+		broadcast: make(chan []byte),
+		join:      make(chan *Client),
+		leave:     make(chan *Client),
+	}
 }
 
 func (p *Party) run() {
-    log.Println("watchparty " + p.party.Id + " live.")
-    
-    done = make(chan bool)
-    go p.broadcastStatus(done)
-    
-    // watchparty will be terminated after this ticker ticks
-    ticker := time.NewTicker(24 * time.Hour)
-    defer func() {
-        done <-true // close broadcastStatus goroutine
-        ticker.Stop() // close watchparty
-    }()
-
-    for {
-        select {
-        case client := <-p.join:
-            log.Printf("%s joined.\n", client.nickname)
-            //p.clients[client] = true
-            p.clients.Store(client, true)
-            handleJoin(p.party, client.send)    // Send party details to newly joined client
-            broadcastJoinOrLeave("new", &p.clients, client)  // Send join notification to peers
-
-        case client := <-p.leave:
-            //_, ok := p.clients[client]
-            _, ok := p.clients.Load(client)
-            if ok {
-                //delete(p.clients, client)
-                p.clients.Delete(client)
-                close(client.send)
-                broadcastJoinOrLeave("leave", &p.clients, client)  // Send join notification to peers
-            }
-
-        case message := <-p.broadcast:
-            msg := wsMessage{}
-            json.Unmarshal([]byte(message), &msg)
-            p.clients.Range(func(key, value any) bool {
-                // Do not broadcast message back to the sender
-                if msg.ClientId != key.(*Client).id {
-                    select {
-                    case key.(*Client).send <- message:
-                    default:
-                        close(key.(*Client).send)
-                        //delete(p.clients, client)
-                        p.clients.Delete(key)
-                    }
-                }
-                return true
-            })
-        }
-
-        case t := <-ticker.C:
-            // close the party after 24 hours
-            log.Prinf("Party %s terminated", p.party.Id)
-            return
-    }
+	log.Println("watchparty " + p.party.Id + " live.")
+
+	done := make(chan bool)
+	go p.broadcastStatus(done)
+
+	// watchparty will be terminated after this ticker ticks
+	ticker := time.NewTicker(24 * time.Second)
+	defer func() {
+		done <- true  // close broadcastStatus goroutine
+		ticker.Stop() // close watchparty
+	}()
+
+	for {
+		select {
+		case client := <-p.join:
+			log.Printf("%s joined.\n", client.nickname)
+			//p.clients[client] = true
+			p.clients.Store(client, true)
+			handleJoin(p.party, client.send)                // Send party details to newly joined client
+			broadcastJoinOrLeave("new", &p.clients, client) // Send join notification to peers
+
+		case client := <-p.leave:
+			//_, ok := p.clients[client]
+			_, ok := p.clients.Load(client)
+			if ok {
+				//delete(p.clients, client)
+				p.clients.Delete(client)
+				close(client.send)
+				broadcastJoinOrLeave("leave", &p.clients, client) // Send join notification to peers
+			}
+
+		case message := <-p.broadcast:
+			msg := wsMessage{}
+			json.Unmarshal([]byte(message), &msg)
+			p.clients.Range(func(key, value any) bool {
+				// Do not broadcast message back to the sender
+				if msg.ClientId != key.(*Client).id {
+					select {
+					case key.(*Client).send <- message:
+					default:
+						close(key.(*Client).send)
+						//delete(p.clients, client)
+						p.clients.Delete(key)
+					}
+				}
+				return true
+			})
+
+		case <-ticker.C:
+			// close the party after 24 hours
+			log.Printf("Party %s terminated", p.party.Id)
+			return
+		}
+
+	}
 }
 
 func (p *Party) broadcastStatus(done chan bool) {
-    ticker := time.NewTicker(2000 * time.Millisecond)
-
-    defer func() {
-        ticker.Stop()
-        log.Printf("%s party ticker stopped\n", p.party.Id)
-    }()
-
-    for {
-        select {
-        case <- done:
-            return
-        case <-ticker.C:
-            broadcastWatchpartyStatus(p)
-        }
-    }
+	ticker := time.NewTicker(2000 * time.Millisecond)
+
+	defer func() {
+		ticker.Stop()
+		log.Printf("%s party ticker stopped\n", p.party.Id)
+	}()
+
+	for {
+		select {
+		case <-done:
+
+			return
+		case <-ticker.C:
+			broadcastWatchpartyStatus(p)
+		}
+	}
 }
diff --git a/server/party_test.go b/server/party_test.go
index b2964ca..5a89278 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -1,15 +1,14 @@
 package main
 
 import (
-	"fmt"
 	"testing"
 )
 
-func TestRun() {
+func TestRun(t *testing.T) {
 	party := createParty("party-123", "user-123", "https://youtube.com")
 
-    go party.run()
+	party.run()
 	// call create party
 	// party.run
 	// wait for end message
-}
\ No newline at end of file
+}

From 938168d00536608fd813af608e5e79fda19b563f Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 14:54:42 +0530
Subject: [PATCH 03/36] debug

---
 server/party.go | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/server/party.go b/server/party.go
index 1b70155..23332fb 100755
--- a/server/party.go
+++ b/server/party.go
@@ -48,8 +48,9 @@ func (p *Party) run() {
 	go p.broadcastStatus(done)
 
 	// watchparty will be terminated after this ticker ticks
-	ticker := time.NewTicker(24 * time.Second)
+	ticker := time.NewTicker(5 * time.Second)
 	defer func() {
+		log.Printf("Party %s terminated", p.party.Id)
 		done <- true  // close broadcastStatus goroutine
 		ticker.Stop() // close watchparty
 	}()
@@ -92,7 +93,6 @@ func (p *Party) run() {
 
 		case <-ticker.C:
 			// close the party after 24 hours
-			log.Printf("Party %s terminated", p.party.Id)
 			return
 		}
 
@@ -110,7 +110,6 @@ func (p *Party) broadcastStatus(done chan bool) {
 	for {
 		select {
 		case <-done:
-
 			return
 		case <-ticker.C:
 			broadcastWatchpartyStatus(p)

From bf6f1326774d2d9e1321251ad54f809ed4b14793 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 14:57:57 +0530
Subject: [PATCH 04/36] debug

---
 server/party.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/server/party.go b/server/party.go
index 23332fb..ceb0dba 100755
--- a/server/party.go
+++ b/server/party.go
@@ -50,7 +50,7 @@ func (p *Party) run() {
 	// watchparty will be terminated after this ticker ticks
 	ticker := time.NewTicker(5 * time.Second)
 	defer func() {
-		log.Printf("Party %s terminated", p.party.Id)
+		
 		done <- true  // close broadcastStatus goroutine
 		ticker.Stop() // close watchparty
 	}()
@@ -93,6 +93,7 @@ func (p *Party) run() {
 
 		case <-ticker.C:
 			// close the party after 24 hours
+			log.Printf("Party %s terminated", p.party.Id)
 			return
 		}
 

From 85abe8c47bc83a601bce9d29137e037711e596a2 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 14:59:44 +0530
Subject: [PATCH 05/36] test

---
 server/party.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/party.go b/server/party.go
index ceb0dba..093f950 100755
--- a/server/party.go
+++ b/server/party.go
@@ -105,7 +105,7 @@ func (p *Party) broadcastStatus(done chan bool) {
 
 	defer func() {
 		ticker.Stop()
-		log.Printf("%s party ticker stopped\n", p.party.Id)
+		log.Printf("%s broadcast stopped\n", p.party.Id)
 	}()
 
 	for {

From 95eb2b8154225ce64cdeedfe6874305ac5dbf137 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:01:00 +0530
Subject: [PATCH 06/36] test

---
 server/party.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/party.go b/server/party.go
index 093f950..7da67fe 100755
--- a/server/party.go
+++ b/server/party.go
@@ -50,7 +50,7 @@ func (p *Party) run() {
 	// watchparty will be terminated after this ticker ticks
 	ticker := time.NewTicker(5 * time.Second)
 	defer func() {
-		
+		log.Println("gg")
 		done <- true  // close broadcastStatus goroutine
 		ticker.Stop() // close watchparty
 	}()

From 45ec879131df6f1a0763fd22a196d570aa5452d4 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:07:38 +0530
Subject: [PATCH 07/36] test

---
 server/party.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/server/party.go b/server/party.go
index 7da67fe..6f5f6b1 100755
--- a/server/party.go
+++ b/server/party.go
@@ -111,6 +111,7 @@ func (p *Party) broadcastStatus(done chan bool) {
 	for {
 		select {
 		case <-done:
+			log.Println("Received message.")
 			return
 		case <-ticker.C:
 			broadcastWatchpartyStatus(p)

From c4c9f7405000b14c35bd0ff8d333a554813cdb6d Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:10:35 +0530
Subject: [PATCH 08/36] test

---
 server/party_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/party_test.go b/server/party_test.go
index 5a89278..65d17c0 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -7,7 +7,7 @@ import (
 func TestRun(t *testing.T) {
 	party := createParty("party-123", "user-123", "https://youtube.com")
 
-	party.run()
+	go party.run()
 	// call create party
 	// party.run
 	// wait for end message

From 59f013a31ec82da8df66056b8840a458ae389f7b Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:12:24 +0530
Subject: [PATCH 09/36] test

---
 server/party_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/server/party_test.go b/server/party_test.go
index 65d17c0..4245b23 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -8,6 +8,8 @@ func TestRun(t *testing.T) {
 	party := createParty("party-123", "user-123", "https://youtube.com")
 
 	go party.run()
+
+	time.Sleep(8 * time.Second)
 	// call create party
 	// party.run
 	// wait for end message

From 637facf5b93e486d2fef8af71982c7b6d28ca855 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:12:56 +0530
Subject: [PATCH 10/36] test

---
 server/party_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/server/party_test.go b/server/party_test.go
index 4245b23..4f17138 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"testing"
+	"time"
 )
 
 func TestRun(t *testing.T) {

From 1cf4019fac2cf6e35d3fa32cd4379f4413c670d1 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:27:59 +0530
Subject: [PATCH 11/36] test

---
 server/client_test.go | 12 ++++++++++++
 server/party.go       |  4 +---
 server/party_test.go  |  5 -----
 3 files changed, 13 insertions(+), 8 deletions(-)
 create mode 100644 server/client_test.go

diff --git a/server/client_test.go b/server/client_test.go
new file mode 100644
index 0000000..be500b9
--- /dev/null
+++ b/server/client_test.go
@@ -0,0 +1,12 @@
+package main
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func TestClient(t *testing.T) {
+	go main()
+	time.Sleep(10*time.Second)
+}
\ No newline at end of file
diff --git a/server/party.go b/server/party.go
index 6f5f6b1..9adf439 100755
--- a/server/party.go
+++ b/server/party.go
@@ -48,9 +48,8 @@ func (p *Party) run() {
 	go p.broadcastStatus(done)
 
 	// watchparty will be terminated after this ticker ticks
-	ticker := time.NewTicker(5 * time.Second)
+	ticker := time.NewTicker(24 * time.Hour)
 	defer func() {
-		log.Println("gg")
 		done <- true  // close broadcastStatus goroutine
 		ticker.Stop() // close watchparty
 	}()
@@ -111,7 +110,6 @@ func (p *Party) broadcastStatus(done chan bool) {
 	for {
 		select {
 		case <-done:
-			log.Println("Received message.")
 			return
 		case <-ticker.C:
 			broadcastWatchpartyStatus(p)
diff --git a/server/party_test.go b/server/party_test.go
index 4f17138..ce9e327 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -7,11 +7,6 @@ import (
 
 func TestRun(t *testing.T) {
 	party := createParty("party-123", "user-123", "https://youtube.com")
-
 	go party.run()
-
 	time.Sleep(8 * time.Second)
-	// call create party
-	// party.run
-	// wait for end message
 }

From fa418c002508877f2aab53c6201554548eab9b1e Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:28:21 +0530
Subject: [PATCH 12/36] test

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index be500b9..9662894 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -1,7 +1,7 @@
 package main
 
 import (
-	"fmt"
+	// "fmt"
 	"testing"
 	"time"
 )

From fb4d95a99f491bec4b014438d975a70cc4c7ce0f Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:46:17 +0530
Subject: [PATCH 13/36] client test

---
 server/client_test.go | 85 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 84 insertions(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index 9662894..ed44af2 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -2,11 +2,94 @@ package main
 
 import (
 	// "fmt"
+	"os"
+	"os/signal"
 	"testing"
 	"time"
+	"http"
+	"github.com/gorilla/websocket"
 )
 
 func TestClient(t *testing.T) {
 	go main()
-	time.Sleep(10*time.Second)
+	time.Sleep(1 * time.Second)
+	createClient()
+	time.Sleep(12*time.Second)
+}
+
+func createClient() {
+	url := "http://localhost:6969/create?userId=user-123&partyId=party-123&src=https://example.com"
+
+	// create watchparty
+	resp, err := http.Get(url)
+	log.Println(string(resp))
+	if err != nil {
+		log.Println("error making request", err)
+	}
+
+	// join as client
+	wsClient()
+}
+
+func wsClient() {
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	u := url.URL{
+		Scheme: "ws",
+		Host: "localhost:6969",
+		Path: "/ws?userId=user-234&partyId=party-123"
+	}
+	log.Printf("connecting to %s", u.String())
+
+	c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
+	if err != nil {
+		log.Fatal("dial:", err)
+	}
+	defer c.Close()
+
+	done := make(chan struct{})
+
+	go func() {
+		defer close(done)
+		for {
+			_, message, err := c.ReadMessage()
+			if err != nil {
+				log.Println("read:", err)
+				return
+			}
+			log.Printf("recv: %s", message)
+		}
+	}()
+
+	ticker := time.NewTicker(time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-done:
+			return
+		case t := <-ticker.C:
+			err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
+			if err != nil {
+				log.Println("write:", err)
+				return
+			}
+		case <-interrupt:
+			log.Println("interrupt")
+
+			// Cleanly close the connection by sending a close message and then
+			// waiting (with timeout) for the server to close the connection.
+			err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+			if err != nil {
+				log.Println("write close:", err)
+				return
+			}
+			select {
+			case <-done:
+			case <-time.After(time.Second):
+			}
+			return
+		}
+	}
 }
\ No newline at end of file

From 082c809e7d743af1736b7decad37156dab67dff5 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:46:51 +0530
Subject: [PATCH 14/36] update import

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index ed44af2..a5fc722 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -6,7 +6,7 @@ import (
 	"os/signal"
 	"testing"
 	"time"
-	"http"
+	"net/http"
 	"github.com/gorilla/websocket"
 )
 

From f2c2fa6bb4326e544775206f0ed1b8df2188a169 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:47:18 +0530
Subject: [PATCH 15/36] debug

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index a5fc722..fa36b32 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -38,7 +38,7 @@ func wsClient() {
 	u := url.URL{
 		Scheme: "ws",
 		Host: "localhost:6969",
-		Path: "/ws?userId=user-234&partyId=party-123"
+		Path: "/ws?userId=user-234&partyId=party-123",
 	}
 	log.Printf("connecting to %s", u.String())
 

From 007bc92ae1525190c7e6e0678f958104e70ceded Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:48:27 +0530
Subject: [PATCH 16/36] update imports

---
 server/client_test.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index fa36b32..af487fe 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -2,11 +2,13 @@ package main
 
 import (
 	// "fmt"
+	"log"
 	"os"
 	"os/signal"
 	"testing"
 	"time"
 	"net/http"
+	"net/url"
 	"github.com/gorilla/websocket"
 )
 
@@ -22,7 +24,7 @@ func createClient() {
 
 	// create watchparty
 	resp, err := http.Get(url)
-	log.Println(string(resp))
+	log.Println(resp.Body)
 	if err != nil {
 		log.Println("error making request", err)
 	}

From 9b311bc71a791a670a1d7f9bd2ad3695d1052832 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:50:02 +0530
Subject: [PATCH 17/36] test

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index af487fe..8556b6e 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -20,7 +20,7 @@ func TestClient(t *testing.T) {
 }
 
 func createClient() {
-	url := "http://localhost:6969/create?userId=user-123&partyId=party-123&src=https://example.com"
+	url := "http://localhost:6969/create?ownerId=user-123&partyId=party-123&src=https://example.com"
 
 	// create watchparty
 	resp, err := http.Get(url)

From 5f9cc9cf64b1450c6df5ccee283a124798215dc7 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:52:11 +0530
Subject: [PATCH 18/36] update url

---
 server/client_test.go | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index 8556b6e..a60b254 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -36,15 +36,10 @@ func createClient() {
 func wsClient() {
 	interrupt := make(chan os.Signal, 1)
 	signal.Notify(interrupt, os.Interrupt)
+	wsUrl = "ws://localhost:6969/ws?userId=user-234&partyId=party-123"
 
-	u := url.URL{
-		Scheme: "ws",
-		Host: "localhost:6969",
-		Path: "/ws?userId=user-234&partyId=party-123",
-	}
-	log.Printf("connecting to %s", u.String())
-
-	c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
+	log.Println("Connecting to", wsUrl)
+	c, _, err := websocket.DefaultDialer.Dial(wsUrl, nil)
 	if err != nil {
 		log.Fatal("dial:", err)
 	}

From a29463b6e6b093c107d5cee9131705a5a2c2b67a Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:52:50 +0530
Subject: [PATCH 19/36] debug

---
 server/client_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index a60b254..cf9dd7c 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -8,7 +8,7 @@ import (
 	"testing"
 	"time"
 	"net/http"
-	"net/url"
+	// "net/url"
 	"github.com/gorilla/websocket"
 )
 
@@ -36,7 +36,7 @@ func createClient() {
 func wsClient() {
 	interrupt := make(chan os.Signal, 1)
 	signal.Notify(interrupt, os.Interrupt)
-	wsUrl = "ws://localhost:6969/ws?userId=user-234&partyId=party-123"
+	wsUrl := "ws://localhost:6969/ws?userId=user-234&partyId=party-123"
 
 	log.Println("Connecting to", wsUrl)
 	c, _, err := websocket.DefaultDialer.Dial(wsUrl, nil)

From e781c538ca8499e0dfe60b4675c37f2865dba653 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:54:39 +0530
Subject: [PATCH 20/36] test

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index cf9dd7c..5e2f45f 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -14,7 +14,7 @@ import (
 
 func TestClient(t *testing.T) {
 	go main()
-	time.Sleep(1 * time.Second)
+	time.Sleep(2 * time.Second)
 	createClient()
 	time.Sleep(12*time.Second)
 }

From 30dcbf9ceb7838b26e516cf40582afee58016899 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:57:03 +0530
Subject: [PATCH 21/36] threads

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index 5e2f45f..953dbfe 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -30,7 +30,7 @@ func createClient() {
 	}
 
 	// join as client
-	wsClient()
+	go wsClient()
 }
 
 func wsClient() {

From e395d6fda9f821890f19d4b1b954b837dde069d7 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 15:59:34 +0530
Subject: [PATCH 22/36] remove os interrupts

---
 server/client_test.go | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index 953dbfe..17187a7 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -3,8 +3,6 @@ package main
 import (
 	// "fmt"
 	"log"
-	"os"
-	"os/signal"
 	"testing"
 	"time"
 	"net/http"
@@ -34,8 +32,6 @@ func createClient() {
 }
 
 func wsClient() {
-	interrupt := make(chan os.Signal, 1)
-	signal.Notify(interrupt, os.Interrupt)
 	wsUrl := "ws://localhost:6969/ws?userId=user-234&partyId=party-123"
 
 	log.Println("Connecting to", wsUrl)
@@ -72,21 +68,5 @@ func wsClient() {
 				log.Println("write:", err)
 				return
 			}
-		case <-interrupt:
-			log.Println("interrupt")
-
-			// Cleanly close the connection by sending a close message and then
-			// waiting (with timeout) for the server to close the connection.
-			err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
-			if err != nil {
-				log.Println("write close:", err)
-				return
-			}
-			select {
-			case <-done:
-			case <-time.After(time.Second):
-			}
-			return
-		}
 	}
 }
\ No newline at end of file

From f41e1436c73f7c7da68445a7a50960aecc8c880a Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:00:03 +0530
Subject: [PATCH 23/36] debug

---
 server/client_test.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/server/client_test.go b/server/client_test.go
index 17187a7..a7fdaa2 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -68,5 +68,6 @@ func wsClient() {
 				log.Println("write:", err)
 				return
 			}
+		}
 	}
 }
\ No newline at end of file

From c00d274e16ea97587cac53e9264896e6f78986d9 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:00:41 +0530
Subject: [PATCH 24/36] logs

---
 server/client_test.go | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index a7fdaa2..4f0771b 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -11,8 +11,10 @@ import (
 )
 
 func TestClient(t *testing.T) {
+	log.Println("Test started.")
 	go main()
 	time.Sleep(2 * time.Second)
+	log.Println("Woke up, creating client now")
 	createClient()
 	time.Sleep(12*time.Second)
 }
@@ -22,7 +24,7 @@ func createClient() {
 
 	// create watchparty
 	resp, err := http.Get(url)
-	log.Println(resp.Body)
+	log.Println("HTTP Response", resp.Body)
 	if err != nil {
 		log.Println("error making request", err)
 	}

From 874a484d5a13a5e2253c0c0084b788b506ad8b9e Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:09:22 +0530
Subject: [PATCH 25/36] check disconnection

---
 server/client.go      |  2 ++
 server/client_test.go | 36 ++++++++++++++++++++----------------
 2 files changed, 22 insertions(+), 16 deletions(-)

diff --git a/server/client.go b/server/client.go
index bbe5c5e..9ce68de 100755
--- a/server/client.go
+++ b/server/client.go
@@ -41,6 +41,7 @@ func initClient(id string, conn *websocket.Conn, party *Party) *Client {
 
 func (c *Client) readPump() {
     defer func() {
+        log.Println("Read pump closed.")
         c.party.leave <- c
         c.conn.Close()
     }()
@@ -87,6 +88,7 @@ func (c *Client) readPump() {
 func (c *Client) writePump() {
     ticker := time.NewTicker(pingPeriod)
     defer func() {
+        log.Println("Write pump closed.")
         ticker.Stop()
         c.conn.Close()
     }()
diff --git a/server/client_test.go b/server/client_test.go
index 4f0771b..37115b0 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -43,10 +43,7 @@ func wsClient() {
 	}
 	defer c.Close()
 
-	done := make(chan struct{})
-
 	go func() {
-		defer close(done)
 		for {
 			_, message, err := c.ReadMessage()
 			if err != nil {
@@ -57,19 +54,26 @@ func wsClient() {
 		}
 	}()
 
-	ticker := time.NewTicker(time.Second)
-	defer ticker.Stop()
+	// Close WS connection after 4s
+	time.Sleep(4 * time.Second)
 
-	for {
-		select {
-		case <-done:
-			return
-		case t := <-ticker.C:
-			err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
-			if err != nil {
-				log.Println("write:", err)
-				return
-			}
-		}
+	err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+	if err != nil {
+		log.Println("write close:", err)
+		return
 	}
+			
+	// ticker := time.NewTicker(time.Second)
+	// defer ticker.Stop()
+
+	// for {
+	// 	select {
+	// 	case t := <-ticker.C:
+	// 		err := c.WriteMessage(websocket.TextMessage, []byte(t.String()))
+	// 		if err != nil {
+	// 			log.Println("write:", err)
+	// 			return
+	// 		}
+	// 	}
+	// }
 }
\ No newline at end of file

From bc0a692e5b17fec1fb514a34ed377c701dbec345 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:09:44 +0530
Subject: [PATCH 26/36] add log

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index 37115b0..19f9fc6 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -56,7 +56,7 @@ func wsClient() {
 
 	// Close WS connection after 4s
 	time.Sleep(4 * time.Second)
-
+	log.Println("Client closing connection.")
 	err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 	if err != nil {
 		log.Println("write close:", err)

From ef9d075b805cdf1bb19df1ff42fe7c83ba2a94aa Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:10:09 +0530
Subject: [PATCH 27/36] debug

---
 server/client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/client_test.go b/server/client_test.go
index 19f9fc6..66e4d48 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -57,7 +57,7 @@ func wsClient() {
 	// Close WS connection after 4s
 	time.Sleep(4 * time.Second)
 	log.Println("Client closing connection.")
-	err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
+	err = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 	if err != nil {
 		log.Println("write close:", err)
 		return

From 1c5ac41eb5624700b82f33109fb251838f925029 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:11:14 +0530
Subject: [PATCH 28/36] change sleep times

---
 server/client_test.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index 66e4d48..0a2877f 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -13,10 +13,10 @@ import (
 func TestClient(t *testing.T) {
 	log.Println("Test started.")
 	go main()
-	time.Sleep(2 * time.Second)
+	time.Sleep(1 * time.Second)
 	log.Println("Woke up, creating client now")
 	createClient()
-	time.Sleep(12*time.Second)
+	time.Sleep(35*time.Second)
 }
 
 func createClient() {
@@ -55,7 +55,7 @@ func wsClient() {
 	}()
 
 	// Close WS connection after 4s
-	time.Sleep(4 * time.Second)
+	time.Sleep(2 * time.Second)
 	log.Println("Client closing connection.")
 	err = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
 	if err != nil {

From f52a2f310db2cc01bdad5c7020e7caea07cd2740 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:25:38 +0530
Subject: [PATCH 29/36] remove watchparty from map

---
 server/client_test.go | 4 ----
 server/party.go       | 5 +++++
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index 0a2877f..6c746f2 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -1,20 +1,16 @@
 package main
 
 import (
-	// "fmt"
 	"log"
 	"testing"
 	"time"
 	"net/http"
-	// "net/url"
 	"github.com/gorilla/websocket"
 )
 
 func TestClient(t *testing.T) {
-	log.Println("Test started.")
 	go main()
 	time.Sleep(1 * time.Second)
-	log.Println("Woke up, creating client now")
 	createClient()
 	time.Sleep(35*time.Second)
 }
diff --git a/server/party.go b/server/party.go
index 9adf439..8353416 100755
--- a/server/party.go
+++ b/server/party.go
@@ -50,6 +50,11 @@ func (p *Party) run() {
 	// watchparty will be terminated after this ticker ticks
 	ticker := time.NewTicker(24 * time.Hour)
 	defer func() {
+		watchparties.Delete(p.party.Id)		// Remove watchparty from map
+		watchparties.Range(func(key, value any) bool {
+			log.Println(key)
+			return true
+		})
 		done <- true  // close broadcastStatus goroutine
 		ticker.Stop() // close watchparty
 	}()

From f96e40e9ccbae5186d1b0547d6b81cfc116fd69f Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:31:36 +0530
Subject: [PATCH 30/36] add party removal test

---
 server/client_test.go |  4 ++--
 server/party.go       |  2 +-
 server/party_test.go  | 14 ++++++++++++++
 3 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index 6c746f2..a287513 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -11,11 +11,11 @@ import (
 func TestClient(t *testing.T) {
 	go main()
 	time.Sleep(1 * time.Second)
-	createClient()
+	createParty()
 	time.Sleep(35*time.Second)
 }
 
-func createClient() {
+func createParty() {
 	url := "http://localhost:6969/create?ownerId=user-123&partyId=party-123&src=https://example.com"
 
 	// create watchparty
diff --git a/server/party.go b/server/party.go
index 8353416..b150220 100755
--- a/server/party.go
+++ b/server/party.go
@@ -48,7 +48,7 @@ func (p *Party) run() {
 	go p.broadcastStatus(done)
 
 	// watchparty will be terminated after this ticker ticks
-	ticker := time.NewTicker(24 * time.Hour)
+	ticker := time.NewTicker(5 * time.Second)
 	defer func() {
 		watchparties.Delete(p.party.Id)		// Remove watchparty from map
 		watchparties.Range(func(key, value any) bool {
diff --git a/server/party_test.go b/server/party_test.go
index ce9e327..ae3b42c 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -10,3 +10,17 @@ func TestRun(t *testing.T) {
 	go party.run()
 	time.Sleep(8 * time.Second)
 }
+
+func TestRemoval {
+	go main()
+	url := "http://localhost:6969/create?ownerId=user-123&partyId=party-123&src=https://example.com"
+
+	// create watchparty
+	resp, err := http.Get(url)
+	log.Println("HTTP Response", resp.Body)
+	if err != nil {
+		log.Println("error making request", err)
+	}
+	
+	time.Sleep(8 * time.Second)
+}
\ No newline at end of file

From d7ae2d3dc5b91d1c1e7fca10ceca0962ef6b2dd3 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:32:24 +0530
Subject: [PATCH 31/36] test

---
 server/party_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/server/party_test.go b/server/party_test.go
index ae3b42c..e93cc3a 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -11,7 +11,7 @@ func TestRun(t *testing.T) {
 	time.Sleep(8 * time.Second)
 }
 
-func TestRemoval {
+func TestWatchpartyRemoval(t *testing.T) {
 	go main()
 	url := "http://localhost:6969/create?ownerId=user-123&partyId=party-123&src=https://example.com"
 
@@ -21,6 +21,6 @@ func TestRemoval {
 	if err != nil {
 		log.Println("error making request", err)
 	}
-	
+
 	time.Sleep(8 * time.Second)
 }
\ No newline at end of file

From c987744f32e5bc85cbd79a65cd70d57620ae9daa Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:34:05 +0530
Subject: [PATCH 32/36] debug

---
 server/party_test.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/server/party_test.go b/server/party_test.go
index e93cc3a..154e167 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -3,6 +3,8 @@ package main
 import (
 	"testing"
 	"time"
+	"net/http"
+	"log"
 )
 
 func TestRun(t *testing.T) {

From fa13ca9fff9b3cfd10fac4343673236c72a6f6c1 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:35:08 +0530
Subject: [PATCH 33/36] rename

---
 server/client_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/server/client_test.go b/server/client_test.go
index a287513..6539208 100644
--- a/server/client_test.go
+++ b/server/client_test.go
@@ -11,11 +11,11 @@ import (
 func TestClient(t *testing.T) {
 	go main()
 	time.Sleep(1 * time.Second)
-	createParty()
+	initWatchparty()
 	time.Sleep(35*time.Second)
 }
 
-func createParty() {
+func initWatchparty() {
 	url := "http://localhost:6969/create?ownerId=user-123&partyId=party-123&src=https://example.com"
 
 	// create watchparty

From 2adbec27e147fe5fb4d6fbd021595abf5d1196d3 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:36:53 +0530
Subject: [PATCH 34/36] log

---
 server/party.go      | 5 +++++
 server/party_test.go | 2 +-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/server/party.go b/server/party.go
index b150220..d7d7cba 100755
--- a/server/party.go
+++ b/server/party.go
@@ -50,6 +50,11 @@ func (p *Party) run() {
 	// watchparty will be terminated after this ticker ticks
 	ticker := time.NewTicker(5 * time.Second)
 	defer func() {
+		log.println(watchparties)
+		watchparties.Range(func(key, value any) bool {
+			log.Println(key)
+			return true
+		})
 		watchparties.Delete(p.party.Id)		// Remove watchparty from map
 		watchparties.Range(func(key, value any) bool {
 			log.Println(key)
diff --git a/server/party_test.go b/server/party_test.go
index 154e167..3935dc9 100644
--- a/server/party_test.go
+++ b/server/party_test.go
@@ -24,5 +24,5 @@ func TestWatchpartyRemoval(t *testing.T) {
 		log.Println("error making request", err)
 	}
 
-	time.Sleep(8 * time.Second)
+	time.Sleep(15 * time.Second)
 }
\ No newline at end of file

From 125aea53829a0d00891a09ae3c39ec10ba33eb67 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:37:20 +0530
Subject: [PATCH 35/36] debug

---
 server/party.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/server/party.go b/server/party.go
index d7d7cba..5260cca 100755
--- a/server/party.go
+++ b/server/party.go
@@ -50,7 +50,7 @@ func (p *Party) run() {
 	// watchparty will be terminated after this ticker ticks
 	ticker := time.NewTicker(5 * time.Second)
 	defer func() {
-		log.println(watchparties)
+		log.Println(watchparties)
 		watchparties.Range(func(key, value any) bool {
 			log.Println(key)
 			return true

From 303e72905728cc9366c70a40973349f5763b1683 Mon Sep 17 00:00:00 2001
From: Debabrata Mondal <debabrata.js@protonmail.com>
Date: Thu, 16 Nov 2023 16:39:35 +0530
Subject: [PATCH 36/36] rearrange logs

---
 server/party.go | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/server/party.go b/server/party.go
index 5260cca..696bbe8 100755
--- a/server/party.go
+++ b/server/party.go
@@ -48,18 +48,10 @@ func (p *Party) run() {
 	go p.broadcastStatus(done)
 
 	// watchparty will be terminated after this ticker ticks
-	ticker := time.NewTicker(5 * time.Second)
+	ticker := time.NewTicker(24 * time.Hour)
 	defer func() {
-		log.Println(watchparties)
-		watchparties.Range(func(key, value any) bool {
-			log.Println(key)
-			return true
-		})
+		log.Printf("Party %s terminated", p.party.Id)
 		watchparties.Delete(p.party.Id)		// Remove watchparty from map
-		watchparties.Range(func(key, value any) bool {
-			log.Println(key)
-			return true
-		})
 		done <- true  // close broadcastStatus goroutine
 		ticker.Stop() // close watchparty
 	}()
@@ -102,7 +94,6 @@ func (p *Party) run() {
 
 		case <-ticker.C:
 			// close the party after 24 hours
-			log.Printf("Party %s terminated", p.party.Id)
 			return
 		}
 
@@ -114,7 +105,6 @@ func (p *Party) broadcastStatus(done chan bool) {
 
 	defer func() {
 		ticker.Stop()
-		log.Printf("%s broadcast stopped\n", p.party.Id)
 	}()
 
 	for {