---
import CategoryBadge from './CategoryBadge.astro';
import Author from '@components/AuthorDisplay.astro';

export interface Props {
  items: any[];
  showCount?: boolean;
  type: 'latest' | 'category' | 'author' | 'tag';
  slug?: string;
  pageInfo?: {
    hasNextPage: boolean;
    endCursor: string | null;
  };
  perLoad?: number;
}

const {
  items = [],
  showCount = false,
  type = 'latest',
  slug = '',
  pageInfo = { hasNextPage: false, endCursor: null },
  perLoad = 11
} = Astro.props;

const loadMoreConfig = {
  type,
  slug,
  perLoad
};

function getCoauthorsNames(coauthors: any[]): string {
  if (!coauthors || coauthors.length === 0) return '';
  
  return coauthors
    .map((coauthor: any) => {
      const name = coauthor?.node?.name || coauthor?.name;
      const nickname = coauthor?.node?.nickname || coauthor?.nickname;
      
      return name; // Возвращаем только имя, ссылки будут в шаблоне
    })
    .filter(Boolean)
    .join(', ');
}

function shouldBeLarge(index: number): boolean {
  if (index < 8) return false;
  return (index - 8) % 11 === 0;
}
---

<section class="posts-section" id="posts-section">
  <h2>
    {showCount && items.length > 0 && (
      <span id="posts-count"> ({items.length})</span>
    )}
  </h2>
  
  <div id="posts-grid" class="posts-grid">
    {items.map((item, index) => {
      const postUrl = item.uri || `/blog/${item.databaseId}`;
      const postDate = new Date(item.date);
      const isLarge = shouldBeLarge(index);
      
      return (
        <article 
          class={`post-card ${isLarge ? 'post-card-large' : ''}`}
          data-large-position={isLarge ? 'first' : ''}
          data-index={index}
          itemscope 
          itemtype="https://schema.org/BlogPosting"
        >
          <div class="post-image-container">
            {item.featuredImage?.node?.sourceUrl ? (
              <img
                src={item.featuredImage.node.sourceUrl} 
                alt={item.featuredImage.node.altText || item.title}
                width="400"
                height="400"
                loading="lazy"
                class="post-image"
                itemprop="image"
              />
            ) : (
              <div class="post-image-placeholder"></div>
            )}


          {item.categories?.nodes?.[0] && (
            <CategoryBadge
              name={item.categories.nodes[0].name}
              color={item.categories.nodes[0].color}
              href={`/${item.categories.nodes[0].slug}`}
              isNews={item.__typename === "ANew"}
            />
          )}
            
            <div class="post-content-overlay">
              <div class="post-meta-overlay">
                <time 
                  datetime={item.date} 
                  class="post-date-overlay"
                  itemprop="datePublished"
                >
                  {postDate.toLocaleDateString('ru-RU', {
                    day: 'numeric',
                    month: 'short',
                    year: 'numeric'
                  }).replace(' г.', '')}
                </time>
              </div>
              
              <a href={postUrl} class="post-title-link" itemprop="url">
                <h3 class="post-title-overlay" itemprop="headline">
                  {item.title}
                </h3>
              </a>

              {item.coauthors && item.coauthors.length > 0 && (
                <div class="coauthors-wrapper" itemprop="author">
                  {item.coauthors.map((coauthor: any, i: number) => {
                    const name = coauthor?.node?.name || coauthor?.name;
                    const nickname = coauthor?.node?.nickname || coauthor?.nickname;
                    console.log(nickname);
                    
                    return (
                      <span class="author-name" key={nickname || name}>
                        {i > 0 && ', '}
                        {nickname ? (
                          <a 
                            href={`/author/${nickname}`}
                            class="author-link"
                            onClick={(e) => e.stopPropagation()}
                          >
                            {name}
                          </a>
                        ) : (
                          <span class="author-name">{name}</span>
                        )}
                      </span>
                    );
                  })}
                </div>
              )}
            </div>
          </div>
          
          <div class="sr-only">
            <h3 itemprop="headline">
              <a href={postUrl} itemprop="url">{item.title}</a>
            </h3>
            <time 
              datetime={item.date} 
              itemprop="datePublished"
            >
              {postDate.toLocaleDateString('ru-RU')}
            </time>
          </div>
        </article>
      );
    })}
  </div>

  <!-- Индикатор загрузки -->
  <div id="loading-indicator" class="loading-indicator" style="display: none;">
    <div class="loading-spinner"></div>
    <p>Загрузка...</p>
  </div>

  <!-- Сообщение об окончании -->
  <div id="no-more-posts" class="no-more-posts" style="display: none;">
    Все статьи загружены
  </div>

  <!-- Sentinel для Intersection Observer -->
  {pageInfo.hasNextPage && (
    <div 
      id="infinity-scroll-sentinel" 
      data-end-cursor={pageInfo.endCursor}
      data-load-config={JSON.stringify(loadMoreConfig)}
      data-current-index={items.length}
    ></div>
  )}
</section>

<script>
  interface PageInfo {
    hasNextPage: boolean;
    endCursor: string | null;
  }

  interface LoadMoreConfig {
    type: 'latest' | 'category' | 'author' | 'tag';
    slug?: string;
    perLoad: number;  // Только perLoad, никакого first
  }

  class InfinityScroll {
    private grid: HTMLElement | null;
    private sentinel: HTMLElement | null;
    private loadingIndicator: HTMLElement | null;
    private noMorePosts: HTMLElement | null;
    private postsCount: HTMLElement | null;
    private observer: IntersectionObserver | null = null;
    private isLoading = false;
    private hasMore = true;
    private endCursor: string | null = null;
    private currentIndex: number;
    private loadMoreConfig: LoadMoreConfig;

    constructor() {
      this.grid = document.getElementById('posts-grid');
      this.sentinel = document.getElementById('infinity-scroll-sentinel');
      this.loadingIndicator = document.getElementById('loading-indicator');
      this.noMorePosts = document.getElementById('no-more-posts');
      this.postsCount = document.getElementById('posts-count');
      
      // Дефолтный конфиг только с perLoad
      const defaultConfig: LoadMoreConfig = { 
        type: 'latest', 
        perLoad: 11 
      };
      
      if (this.sentinel) {
        this.endCursor = this.sentinel.dataset.endCursor || null;
        this.currentIndex = parseInt(this.sentinel.dataset.currentIndex || '0');
        
        try {
          // Парсим конфиг из data-атрибута
          const parsedConfig = JSON.parse(this.sentinel.dataset.loadConfig || '{}');
          this.loadMoreConfig = { 
            ...defaultConfig, 
            ...parsedConfig,
            // Убеждаемся, что perLoad определен
            perLoad: parsedConfig.perLoad || defaultConfig.perLoad
          };
        } catch {
          this.loadMoreConfig = defaultConfig;
        }
      } else {
        this.loadMoreConfig = defaultConfig;
        this.currentIndex = 0;
      }

      this.init();
    }

    private init() {
      if (!this.sentinel || !this.grid) return;

      this.observer = new IntersectionObserver(
        (entries) => {
          entries.forEach((entry) => {
            if (entry.isIntersecting && !this.isLoading && this.hasMore) {
              this.loadMorePosts();
            }
          });
        },
        {
          rootMargin: '200px',
          threshold: 0.1
        }
      );

      this.observer.observe(this.sentinel);
    }

    private async loadMorePosts() {
      if (this.isLoading || !this.hasMore) return;

      this.isLoading = true;
      this.showLoading();

      try {
        // Отправляем только perLoad (никакого first)
        const response = await fetch('/load-more-posts', {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json',
          },
          body: JSON.stringify({
            perLoad: this.loadMoreConfig.perLoad,
            after: this.endCursor,
            type: this.loadMoreConfig.type,
            slug: this.loadMoreConfig.slug,
            startIndex: this.currentIndex
          })
        });

        if (!response.ok) {
          throw new Error(`Ошибка загрузки постов: ${response.status}`);
        }

        const html = await response.text();
        
        const temp = document.createElement('div');
        temp.innerHTML = html;
        
        const newSentinel = temp.querySelector('#infinity-scroll-sentinel');
        let newEndCursor = null;
        let hasNextPage = false;
        
        if (newSentinel) {
          newEndCursor = newSentinel.dataset.endCursor || null;
          hasNextPage = true;
        }
        
        const articles = temp.querySelectorAll('article');
        const fragment = document.createDocumentFragment();
        
        articles.forEach(article => {
          fragment.appendChild(article.cloneNode(true));
        });
        
        this.grid?.appendChild(fragment);
        
        // Используем perLoad для увеличения индекса
        this.currentIndex += this.loadMoreConfig.perLoad;
        this.endCursor = newEndCursor;
        this.hasMore = hasNextPage;

        if (this.postsCount) {
          this.postsCount.textContent = ` (${this.currentIndex})`;
        }

        if (this.sentinel) {
          this.sentinel.dataset.currentIndex = String(this.currentIndex);
          this.sentinel.dataset.endCursor = newEndCursor || '';
          
          if (!hasNextPage) {
            this.showNoMorePosts();
          }
        }
      } catch (error) {
        console.error('Ошибка загрузки:', error);
        this.hasMore = false;
        this.showError();
      } finally {
        this.isLoading = false;
        this.hideLoading();
      }
    }

    private showLoading() {
      if (this.loadingIndicator) {
        this.loadingIndicator.style.display = 'block';
      }
    }

    private hideLoading() {
      if (this.loadingIndicator) {
        this.loadingIndicator.style.display = 'none';
      }
    }

    private showNoMorePosts() {
      if (this.sentinel && this.observer) {
        this.observer.unobserve(this.sentinel);
        this.sentinel.style.display = 'none';
      }
      
      if (this.noMorePosts) {
        this.noMorePosts.style.display = 'block';
      }
    }

    private showError() {
      if (this.noMorePosts) {
        this.noMorePosts.textContent = 'Ошибка загрузки. Попробуйте обновить страницу.';
        this.noMorePosts.style.display = 'block';
      }
    }

    public destroy() {
      if (this.observer && this.sentinel) {
        this.observer.unobserve(this.sentinel);
      }
      this.observer?.disconnect();
    }
  }

  let infinityScroll: InfinityScroll | null = null;

  if ('requestIdleCallback' in window) {
    requestIdleCallback(() => {
      infinityScroll = new InfinityScroll();
    }, { timeout: 2000 });
  } else {
    setTimeout(() => {
      infinityScroll = new InfinityScroll();
    }, 200);
  }

  document.addEventListener('astro:before-swap', () => {
    infinityScroll?.destroy();
  });
</script>