getPostThreadV2 parent reply chain

main.go

···
 				ctx,
 				skeletonposts,
 				20,
-				func(ctx context.Context, raw *appbsky.FeedDefs_SkeletonFeedPost) (*appbsky.FeedDefs_FeedViewPost, error) {
+				func(ctx context.Context, raw *appbsky.FeedDefs_SkeletonFeedPost, idx int) (*appbsky.FeedDefs_FeedViewPost, error) {
 					post, _, err := appbskyfeeddefs.PostView(ctx, raw.Post, sl, cs, BSKYIMAGECDN_URL, viewer, 2)
 					if err != nil {
 						return nil, err
···
 			//var thread []*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem
 
 			var skeletonposts []string
-			skeletonposts = append(skeletonposts, threadAnchorURI.String())
 
 			emptystrarray := &[]string{}
 			limit := 100
 
+			// recurse to the top
+			parentsMap := map[string]*appbsky.FeedDefs_PostView{}
+			current := threadAnchorURI
+			iteration := 0
+			for true {
+				iteration = iteration + 1
+				if iteration > 10 {
+					break
+				}
+				recordaturi, err := syntax.ParseATURI("at://" + current.Authority().String() + "/" + string(current.Collection()) + "/" + string(current.RecordKey()))
+				if err != nil {
+					break
+				}
+				// loop
+				postView, postRecord, err := appbskyfeeddefs.PostView(ctx, recordaturi.String(), sl, cs, BSKYIMAGECDN_URL, viewer, 3)
+				if err != nil {
+					break
+				}
+				if postView == nil {
+					break
+				}
+				//if iteration != 1 {
+				skeletonposts = append([]string{recordaturi.String()}, skeletonposts...)
+				//}
+				parentsMap[recordaturi.String()] = postView
+				if postRecord != nil && postRecord.Reply != nil && postRecord.Reply.Parent != nil && postRecord.Reply.Root != nil {
+					if postRecord.Reply.Parent.Uri == postRecord.Reply.Root.Uri {
+						//break
+						iteration = 9
+					}
+
+					current, err = syntax.ParseATURI(postRecord.Reply.Parent.Uri)
+					if err != nil {
+						break
+					}
+				} else {
+					log.Println("what huh what hwat")
+					break //whatt
+				}
+
+			}
+
+			//skeletonposts = append(skeletonposts, threadAnchorURI.String())
 			// todo: theres a cursor!!! pagination please!
-			// todo: also i doubt im gonna do proper threadding so make sure to remind me to do it properly thanks
+			// todo: also i doubt im gonna do proper threadding right now, so make sure to remind me to do it properly some time later thanks
 			//rootReplies, _ := constellation.GetBacklinks(ctx, cs, string(threadAnchorURI), "app.bsky.feed.post:reply.root.uri", *emptystrarray, &limit, nil)
 			parentReplies, _ := constellation.GetBacklinks(ctx, cs, string(threadAnchorURI), "app.bsky.feed.post:reply.parent.uri", *emptystrarray, &limit, nil)
 
···
 				}
 				skeletonposts = append(skeletonposts, recordaturi.String())
 			}
+			maplen := len(parentsMap)
 			concurrentResults := MapConcurrent(
 				ctx,
 				skeletonposts,
 				20,
-				func(ctx context.Context, raw string) (*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, error) {
-					post, _, err := appbskyfeeddefs.PostView(ctx, raw, sl, cs, BSKYIMAGECDN_URL, viewer, 3)
-					if err != nil {
-						return nil, err
-					}
-					if post == nil {
-						return nil, fmt.Errorf("post not found")
+				func(ctx context.Context, raw string, idx int) (*appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem, error) {
+					var postView *appbsky.FeedDefs_PostView
+					fromParentChain := false
+					postView, ok := parentsMap[raw]
+					if !ok {
+						post, _, err := appbskyfeeddefs.PostView(ctx, raw, sl, cs, BSKYIMAGECDN_URL, viewer, 3)
+						if err != nil {
+							return nil, err
+						}
+						if post == nil {
+							return nil, fmt.Errorf("post not found")
+						}
+						postView = post
+					} else {
+						fromParentChain = true
 					}
 
 					depth := int64(1)
 					if raw == threadAnchorURI.String() {
 						depth = 0
+					}
+					if fromParentChain {
+						depth = int64(0 - maplen + idx + 1)
 					}
 
 					return &appbsky.UnspeccedGetPostThreadOtherV2_ThreadItem{
···
 								// OpThread bool               `json:"opThread" cborgen:"opThread"`
 								OpThread: false, // todo: placeholder
 								// Post     *FeedDefs_PostView `json:"post" cborgen:"post"`
-								Post: post,
+								Post: postView,
 							},
 						},
 					}, nil

utils.go

···
 	ctx context.Context,
 	items []T,
 	concurrencyLimit int,
-	mapper func(context.Context, T) (R, error),
+	mapper func(context.Context, T, int) (R, error),
 ) []AsyncResult[R] {
 	if len(items) == 0 {
 		return nil
···
 				return
 			}
 
-			val, err := mapper(ctx, input)
+			val, err := mapper(ctx, input, idx)
 			results[idx] = AsyncResult[R]{Value: val, Err: err}
 		}(i, item)
 	}