/**
 *******************************************************************************
 * Copyright (C) 2001-2006, International Business Machines Corporation and    *
 * others. All Rights Reserved.                                                *
 *******************************************************************************
 */
package com.ibm.icu.dev.test.util;

import com.ibm.icu.impl.ICULocaleService;
import com.ibm.icu.impl.ICUService;
import com.ibm.icu.text.Collator;
import com.ibm.icu.util.ULocale;

import java.util.EventListener;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.SortedMap;

public class ICUServiceTestSample {
    static public void main(String[] args) {
        HelloServiceClient client = new HelloServiceClient();

        Thread t = new HelloUpdateThread();
        t.start();
        try {
            t.join();
        }
        catch (InterruptedException e) {
        }
        System.out.println("done");
        if(client==null){
        }
    }

    /**
     * A class that displays the current names in the Hello service.
     * Each time the service changes, it redisplays the names.
     */
    static class HelloServiceClient implements HelloService.HelloServiceListener {

        HelloServiceClient() {
            HelloService.addListener(this);
            display();
        }


        /**
         * This will be called in the notification thread of
         * ICUNotifier.  ICUNotifier could spawn a (non-daemon) thread
         * for each listener, so that impolite listeners wouldn't hold
         * up notification, but right now it doesn't.  Instead, all
         * notifications are delivered on the notification thread.
         * Since that's a daemon thread, a notification might not
         * complete before main terminates.  
         */
        public void helloServiceChanged() {
            display();
        }

        private void display() {
            Map names = HelloService.getDisplayNames(ULocale.US);
            System.out.println("displaying " + names.size() + " names.");
            Iterator iter = names.entrySet().iterator();
            while (iter.hasNext()) {
                Entry entry = (Entry)iter.next();
                String displayName = (String)entry.getKey();
                HelloService service = HelloService.get((String)entry.getValue());
                System.out.println(displayName + " says " + service.hello());
                try {
                    Thread.sleep(50);
                }
                catch (InterruptedException e) {
                }
            }
            System.out.println("----");
        }
    }

    /**
     * A thread to update the service.
     */
    static class HelloUpdateThread extends Thread {
        String[][] updates = {
            { "Hey", "en_US_INFORMAL" },
            { "Hallo", "de_DE_INFORMAL" },
            { "Yo!", "en_US_CALIFORNIA_INFORMAL" },
            { "Chi Fanle Ma?", "zh__INFORMAL" },
            { "Munch munch... Burger?", "en" },
            { "Sniff", "fr" },
            { "TongZhi! MaoZeDong SiXiang Wan Sui!", "zh_CN" },
            { "Bier? Ja!", "de" },
        };
        public void run() {
            for (int i = 0; i < updates.length; ++i) {
                try {
                    Thread.sleep(500);
                }
                catch (InterruptedException e) {
                }
                HelloService.register(updates[i][0], new ULocale(updates[i][1]));
            }
        }
    }

    /**
     * An example service that wraps an ICU service in order to export custom API and
     * notification. The service just implements 'hello'.
     */
    static final class HelloService {
        private static ICUService registry;
        private String name;
    
        private HelloService(String name) { 
            this.name = name; 
        }
    
        /**
         * The hello service...
         */
        public String hello() { 
            return name; 
        }
        
        public String toString() { 
            return super.toString() + ": " + name; 
        }
    
        /**
         * Deferred init.
         */
        private static ICUService registry() {
            if (registry == null) {
                initRegistry();
            }
            return registry;
        }
    
        private static void initRegistry() {
            registry = new ICULocaleService() {
                    protected boolean acceptsListener(EventListener l) {
                        return true; // we already verify in our wrapper APIs
                    }
                    protected void notifyListener(EventListener l) {
                        ((HelloServiceListener)l).helloServiceChanged();
                    }
                };
    
            // initialize
            doRegister("Hello", "en");
            doRegister("Bonjour", "fr");
            doRegister("Ni Hao", "zh_CN");
            doRegister("Guten Tag", "de");
        }
    
        /**
         * A custom listener for changes to this service.  We don't need to
         * point to the service since it is defined by this class and not
         * an object.
         */
        public static interface HelloServiceListener extends EventListener {
            public void helloServiceChanged();
        }
    
        /**
         * Type-safe notification for this service.
         */
        public static void addListener(HelloServiceListener l) {
            registry().addListener(l);
        }
    
        /**
         * Type-safe notification for this service.
         */
        public static void removeListener(HelloServiceListener l) {
            registry().removeListener(l);
        }
    
        /**
         * Type-safe access to the service.
         */
        public static HelloService get(String id) {
            return (HelloService)registry().get(id);
        }
    
        public static Set getVisibleIDs() {
            return registry().getVisibleIDs();
        }
    
        public static Map getDisplayNames(ULocale locale) {
            return getDisplayNames(registry(), locale);
        }
    
        /**
         * Register a new hello string for this locale.
         */
        public static void register(String helloString, ULocale locale) {
            if (helloString == null || locale == null) {
                throw new NullPointerException();
            }
            doRegister(helloString, locale.toString());
        }
    
        private static void doRegister(String hello, String id) {
            registry().registerObject(new HelloService(hello), id);
        }
        /**
         * Convenience override of getDisplayNames(ULocale, Comparator, String) that
         * uses the default collator for the locale as the comparator to
         * sort the display names, and null for the matchID.
         */
        public static SortedMap getDisplayNames(ICUService service, ULocale locale) {
            Collator col = Collator.getInstance(locale);
            return service.getDisplayNames(locale, col, null);
        }
    }
}