/*

  *   SONEWS News Server

  *   see AUTHORS for the list of contributors

  *

  *   This program is free software: you can redistribute it and/or modify

  *   it under the terms of the GNU General Public License as published by

  *   the Free Software Foundation, either version 3 of the License, or

  *   (at your option) any later version.

  *

  *   This program is distributed in the hope that it will be useful,

  *   but WITHOUT ANY WARRANTY; without even the implied warranty of

  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  *   GNU General Public License for more details.

  *

  *   You should have received a copy of the GNU General Public License

  *   along with this program.  If not, see <http://www.gnu.org/licenses/>.

  */

 package org.sonews.storage;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.List;

 import org.sonews.util.Pair;

 /**

  * An aggregated group is a group consisting of several "real" group.

  * @author Christian Lins

  * @since sonews/1.0

  */

 class AggregatedGroup extends Channel

 {

   static class GroupElement

   {

     private Group group;

     private long  offsetStart, offsetEnd;

     public GroupElement(Group group, long offsetStart, long offsetEnd)

     {

       this.group       = group;

       this.offsetEnd   = offsetEnd;

       this.offsetStart = offsetStart;

     }

   }

   public static List<Channel> getAll()

   {

     List<Channel> all = new ArrayList<Channel>();

     all.add(getByName("agg.test"));

     return all;

   }

   public static AggregatedGroup getByName(String name)

   {

     if("agg.test".equals(name))

     {

       AggregatedGroup agroup = new AggregatedGroup(name);

       agroup.addGroup(Group.getByName("agg.test0"), 0, 1000);

       agroup.addGroup(Group.getByName("agg.test1"), 2000, 4000);

       return agroup;

     }

     else

       return null;

   }

   private GroupElement[] groups = new GroupElement[2];

   private String         name;

   public AggregatedGroup(String name)

   {

     this.name = name;

   }

   private long aggIdxToIdx(long aggIdx)

     throws StorageBackendException

   {

     assert groups != null && groups.length == 2;

     assert groups[0] != null;

     assert groups[1] != null;

     // Search in indices of group one

     List<Long> idxs0 = groups[0].group.getArticleNumbers();

     Collections.sort(idxs0);

     for(long idx : idxs0)

     {

       if(idx == aggIdx)

       {

         return idx;

       }

     }

     // Given aggIdx must be an index of group two

     List<Long> idxs1 = groups[1].group.getArticleNumbers();

     return 0;

   }

   private long idxToAggIdx(long idx)

   {

     return 0;

   }

   /**

    * Adds the given group to this aggregated set.

    * @param group

    * @param offsetStart Lower limit for the article ids range

    */

   public void addGroup(Group group, long offsetStart, long offsetEnd)

   {

     this.groups[groups[0] == null ? 0 : 1]

       = new GroupElement(group, offsetStart, offsetEnd);

   }

   @Override

   public Article getArticle(long idx)

     throws StorageBackendException

   {

     Article article = null;

     for(GroupElement groupEl : groups)

     {

       if(groupEl.offsetStart <= idx && groupEl.offsetEnd >= idx)

       {

         article = groupEl.group.getArticle(idx - groupEl.offsetStart);

         break;

       }

     }

     return article;

   }

   @Override

   public List<Pair<Long, ArticleHead>> getArticleHeads(

     final long first, final long last)

     throws StorageBackendException

   {

     List<Pair<Long, ArticleHead>> heads = new ArrayList<Pair<Long, ArticleHead>>();

     for(GroupElement groupEl : groups)

     {

       List<Pair<Long, ArticleHead>> partHeads = new ArrayList<Pair<Long, ArticleHead>>();

       if(groupEl.offsetStart <= first && groupEl.offsetEnd >= first)

       {

         long end = Math.min(groupEl.offsetEnd, last);

         partHeads = groupEl.group.getArticleHeads

           (first - groupEl.offsetStart, end - groupEl.offsetStart);

       }

       else if(groupEl.offsetStart <= last && groupEl.offsetEnd >= last)

       {

         long start = Math.max(groupEl.offsetStart, first);

         partHeads = groupEl.group.getArticleHeads

           (start - groupEl.offsetStart, last - groupEl.offsetStart);

       }

       for(Pair<Long, ArticleHead> partHead : partHeads)

       {

         heads.add(new Pair<Long, ArticleHead>(

           partHead.getA() + groupEl.offsetStart, partHead.getB()));

       }

     }

     return heads;

   }

   @Override

   public List<Long> getArticleNumbers()

     throws StorageBackendException

   {

     List<Long> articleNumbers = new ArrayList<Long>();

     for(GroupElement groupEl : groups)

     {

       List<Long> partNums = groupEl.group.getArticleNumbers();

       for(Long partNum : partNums)

       {

         articleNumbers.add(partNum + groupEl.offsetStart);

       }

     }

     return articleNumbers;

   }

   @Override

   public long getIndexOf(Article art)

     throws StorageBackendException

   {

     for(GroupElement groupEl : groups)

     {

       long idx = groupEl.group.getIndexOf(art);

       if(idx > 0)

       {

         return idx;

       }

     }

     return -1;

   }

   public long getInternalID()

   {

     return -1;

   }

   @Override

   public String getName()

   {

     return this.name;

   }

   @Override

   public long getFirstArticleNumber()

     throws StorageBackendException

   {

     long first = Long.MAX_VALUE;

     for(GroupElement groupEl : groups)

     {

       first = Math.min(first, groupEl.group.getFirstArticleNumber() + groupEl.offsetStart);

     }

     return first;

   }

   @Override

   public long getLastArticleNumber()

     throws StorageBackendException

   {

     long last = 1;

     for(GroupElement groupEl : groups)

     {

       last = Math.max(last, groupEl.group.getLastArticleNumber() + groupEl.offsetStart);

     }

     return last + getPostingsCount(); // This is a hack

   }

   public long getPostingsCount()

     throws StorageBackendException

   {

     long postings = 0;

     for(GroupElement groupEl : groups)

     {

       postings += groupEl.group.getPostingsCount();

     }

     return postings;

   }

   public boolean isDeleted()

   {

     return false;

   }

   public boolean isWriteable()

   {

     return false;

   }

 }