/*
 * Copyright 2005-2010 the original author or authors.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.wamblee.photos.wicket;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.logging.Logger;
import javax.inject.Inject;

import org.apache.wicket.PageParameters;
import org.apache.wicket.markup.html.WebMarkupContainer;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.image.Image;
import org.apache.wicket.markup.html.link.Link;
import org.apache.wicket.markup.repeater.RepeatingView;
import org.apache.wicket.resource.ByteArrayResource;
import org.wamblee.photos.model.Album;
import org.wamblee.photos.model.Photo;
import org.wamblee.photos.model.PhotoEntry;
import org.wamblee.photos.model.plumbing.AllPhotos;
import org.wamblee.photos.model.plumbing.AuthorizedPhotos;
import org.wamblee.security.authentication.User;
import org.wamblee.security.authentication.UserAdministration;

/**
 * Homepage
 */
public class HomePage extends BasePage {

    private static final Logger LOGGER = Logger.getLogger(HomePage.class.getName());

    private static final long serialVersionUID = 1L;

    @Inject
    private transient User user;

    @Inject
    private transient UserAdministration userAdmin;

    // TODO the state should be stored as a path.

    @Inject
    @AllPhotos
    private transient Album album;

    @Inject
    @AuthorizedPhotos
    private transient Album authorized;

    private class SerializableEntryLink extends Link {

        private String path;

        public SerializableEntryLink(String aId, String aPath) {
            super(aId);
            path = aPath;
        }

        @Override
        public void onClick() {
            System.out.println("Entry " + path + " was clicked");
            PageParameters pars = new PageParameters();
            pars.put("path", path);
            setResponsePage(HomePage.class, pars);
        }
    }

    private String path;

    /**
     * Constructor that is invoked when page is invoked without a session.
     *
     * @param parameters Page parameters
     */
    public HomePage(final PageParameters parameters) throws Exception {
        super();

        path = parameters.getString("path", "/");
        if (!path.startsWith("/")) {
            info("Invalid album '" + path + "', showing root album instead");
            path = "/";
        }

        add(new Label("message", "Hello world!"));

        System.out.println("Currently logged in user: " + user);

        List<String> usernames = userAdmin.getUsers();
        System.out.println("All user names: " + usernames);

        usernames = userAdmin.getUsers("public");
        System.out.println("Users in group public: " + usernames);

        System.out.println("Entries: " + album.size());
        for (int i = 0; i < album.size(); i++) {
            PhotoEntry entry = album.getEntry(i);
            System.out.println("Entry " + i + " " + entry.getId() + " " + entry.getPath());
        }

        System.out.println("Authorized Entries: " + authorized.size());
        for (int i = 0; i < authorized.size(); i++) {
            PhotoEntry entry = authorized.getEntry(i);
            System.out.println("Entry " + i + " " + entry.getId() + " " + entry.getPath());
        }

        PhotoEntry current = authorized.getEntry(path);

        if (current instanceof Photo) {
            throw new RuntimeException("Photo entry viewing not yet implemented");
        }

        Album album = (Album) current;

        int ientry = 0;
        int irow = 0;
        RepeatingView row = new RepeatingView("row");
        add(row);
        while (irow < 5 && ientry < album.size()) {
            int icolumn = 0;
            WebMarkupContainer columns = new WebMarkupContainer(row.newChildId());
            row.add(columns);
            RepeatingView column = new RepeatingView("column");
            columns.add(column);
            while (icolumn < 5 && ientry < album.size()) {
                WebMarkupContainer thumbnail = new WebMarkupContainer(column.newChildId());
                column.add(thumbnail);

                final PhotoEntry entry = album.getEntry(ientry);
                Link link = new SerializableEntryLink("thumbnail", entry.getPath());
                thumbnail.add(link);
                ImageData data = getData(entry);

                // TODO very inefficient. all data is loaded when generating the page.
                link.add(new Image("image", new ByteArrayResource(data.getContentType(), data.getData())));

                link.add(new Label("name", album.getEntry(ientry).getId()));
                icolumn++;
                ientry++;
            }
            irow++;
        }
    }

    public static final class ImageData {
        private String contentType;
        private byte[] data;

        public ImageData(String aContentType, byte[] aData) {
            contentType = aContentType;
            data = aData;
        }

        public String getContentType() {
            return contentType;
        }

        public byte[] getData() {
            return data;
        }
    }

    private ImageData getData(PhotoEntry aEntry) {
        if (aEntry instanceof Photo) {
            return getData((Photo) aEntry);
        } else if (aEntry instanceof Album) {
            return getData((Album) aEntry);
        } else {
            throw new RuntimeException("Unsupported type " + aEntry.getClass().getName());
        }
    }

    private ImageData getData(Photo aPhoto) {
        try (InputStream is = aPhoto.getThumbNail()) {
            return new ImageData("image/jpeg", getBytes(is));
        }
        catch (IOException e) {
            // to improve.
            throw new RuntimeException("Cannot read photo", e);
        }
    }

    private byte[] getBytes(InputStream is) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] block = new byte[1024];
        int n = is.read(block);
        while (n > 0) {
            bos.write(block, 0, n);
            n = is.read(block);
        }
        return bos.toByteArray();
    }

    private ImageData getData(Album aAlbum) {
        try (InputStream is = getClass().getResourceAsStream("folder.png")) {
            return new ImageData("image/png", getBytes(is));
        }
        catch (IOException e) {
            throw new RuntimeException("Cannot read album jpg", e);
        }
    }
}